unaencoderapi.pas

Voice Commnucation Components for Delphi

const
  // -- ogg additional error codes --
  OV_ERR_FILEHANDLE_INVALID	= -6001;

type
  // --  --
  pConvBuffArray = ^tConvBuffArray;
  tConvBuffArray = array[0 .. maxInt div sizeOf(ogg_int16_t) - 1] of ogg_int16_t;

  unaOggFile = class;

  //
  // -- unaVorbisDecoder --
  //

  {DP:CLASS
    Provides interface of Vorbis/Ogg stream decoding.
    <BR>Requires Vorbis/Ogg libraries DLLs (ogg.dll and vorbis.dll)
  }
  unaVorbisDecoder = class(unaVorbisAbstract)
  private
    f_outBufSizeInSamples: unsigned;
    //
    f_vorbisEos: int;
    f_oggFile: unaOggFile;
  protected
    {DP:METHOD
      Opens Vorbis decoder.
    }
    function doOpen(): UNA_ENCODER_ERR; override;
    {DP:METHOD
      Configures Vorbis decoder.
    }
    function doSetConfig(config: pointer): UNA_ENCODER_ERR; override;
    {DP:METHOD
      Closes Vorbis decoder.
    }
    function doClose(): UNA_ENCODER_ERR; override;
    {DP:METHOD
      Decodes a chunk of data.
    }
    function doEncode(data: pointer; nBytes: unsigned; out bytesUsed: unsigned): UNA_ENCODER_ERR; override;
  public
    {DP:METHOD
      Reads specified amount of data from decoder output.
      Returns number of bytes actually read, or 0 if no more data is available.
    }
    function readDecode(buf: pointer; size: unsigned): unsigned;
    {DP:METHOD
      Feeds decoder with new packet.
    }
    function synthesis_packet(const packet: tOgg_packet): int;
    {DP:METHOD
      Feeds decoder with new data from buffer.
    }
    function synthesis_blockin(): int;
    {DP:METHOD
      Reads PCM data (if any) from decoder. Returns number of samples read.
    }
    function synthesis_pcmout(var pcm: pSingleSamples): int;
    //
    {DP:METHOD
      Initializates decoder.
    }
    function decode_initBuffer(size: unsigned): int;
    {DP:METHOD
      Returns number of samples decoded.
    }
    function decode_packet(const packet: tOgg_packet; out wasClipping: bool): int;
  end;


  //
  //  - unaOggFile --
  //

  tUnaDataAvailableEvent = procedure (sender: tObject; data: pointer; size: unsigned) of object;

  {DP:CLASS
    Provides interface of Ogg file stream.
    <BR>Requires Ogg library DLL (ogg.dll)
  }
  unaOggFile = class(tObject)
  private
    f_onDA: tUnaDataAvailableEvent;
    //
    f_fileName: string;
    f_fileHandle: tHandle;
    f_serialno: int;
    f_access: unsigned;
    f_errorCode: int;
    //
    f_os: tOgg_stream_state;
    f_oy: tOgg_sync_state; //* sync and verify incoming physical bitstream */
    //
    function get_os: pOgg_stream_state;
  public
    {DP:METHOD
      Creates or opens existing Ogg stream file.
    }
    constructor create(const fileName: string; serialno: int = -1; access: unsigned = GENERIC_READ);
    procedure AfterConstruction(); override;
    procedure BeforeDestruction(); override;
    //
    {DP:METHOD
      Writes packet into Ogg stream.
    }
    function packetIn(const packet: tOgg_packet): int;
    {DP:METHOD
      Flushes all pending segments/pages. Next packet is ensured to start on a new page.
    }
    function flush(): int;
    {DP:METHOD
      Writes out any pending pages into a physical file.
    }
    function pageOut(): int;
    //
    {DP:METHOD
      Initializes Ogg reader.
    }
    function sync_init(): int;
    {DP:METHOD
      Allocates Ogg reader buffer with given size.
    }
    function sync_buffer(size: unsigned): pointer;
    {DP:METHOD
      Feeds Ogg reader with new data from buffer.
    }
    function sync_wrote(size: unsigned): int;
    {DP:METHOD
      Pops new page (if any) from Ogg reader.
    }
    function sync_pageout(var og: tOgg_page): int;
    {DP:METHOD
      Feeds Ogg reader with size bytes from physical file.
    }
    function sync_blockRead(size: unsigned): unsigned;
    //
    {DP:METHOD
      Feeds Ogg stream with new page.
    }
    function stream_pagein(const og: tOgg_page): int;
    {DP:METHOD
      Pops Ogg packet (if any) from Ogg stream.
    }
    function stream_packetOut(var op: tOgg_packet): int;
    //
    {DP:METHOD
      Initializes Vorbis decoder with header data from Ogg stream.
      <BR>Returns 0 if successfull.
    }
    function vorbis_decode_int(decoder: unaVorbisDecoder): int;
    //
    property os: pOgg_stream_state read get_os;
    property errorCode: int read f_errorCode;
    property onDataAvailable: tUnaDataAvailableEvent read f_onDA write f_onDA;
  end;


// ================== BASS LIBRARY WITH MP3 DECODER ======================

const
  // error codes
  BASS_ERROR_NOLIBRARY	= BASS_ERROR_UNKNOWN - 1;

type

  unaBass = class;
  unaBassChannel = class;

  unaBassDSPCallbackEvent = procedure(sender: tobject; channel: DWORD; data: pointer; len: unsigned) of object;

  unaBassConsumer = class
  private
    f_bass: unaBass;
    f_isValid: bool;
    f_handle: DWORD;
    f_channel: unaBassChannel;
    f_dsp: HDSP;
    f_onDSPCallback: unaBassDSPCallbackEvent;
    //
    procedure initDSPCallback();
    procedure freeDSPCallback();
  protected
    procedure setHandle(value: DWORD); virtual;
    procedure freeResources(); virtual;
    //
    function supportsDSP(): bool; virtual;
    procedure doDSPCallback(channel: DWORD; data: pointer; len: unsigned); virtual;
  public
    constructor create(bass: unaBass; noChannel: bool = false);
    procedure BeforeDestruction(); override;
    //
    function bytes2seconds(pos: QWORD): FLOAT;
    function seconds2bytes(const pos: FLOAT): QWORD;
    //
    property bass: unaBass read f_bass;
    property handle: DWORD read f_handle write setHandle;
    property asChannel: unaBassChannel read f_channel;
    //
    property onDSPCallback: unaBassDSPCallbackEvent read f_onDSPCallback write f_onDSPCallback;
  end;


  {DP:CLASS
    Provides interface for BASS.
    <BR>Requires BASS library (bass.dll)
  }
  unaBass = class
  private
    f_bass: tBassProc;
    f_isValid: bool;
    //
    f_bassLibName: string;
    f_deviceId: int;
    f_freq: DWORD;
    f_flags: DWORD;
    f_win: HWND;
    //
    f_consumers: unaObjectList;
  protected
    function bass_init(device: Integer; freq, flags: DWORD; win: HWND): bool;
    procedure bass_free();
  public
    constructor create(const libraryFileName: string = ''; deviceId: int = {$IFDEF BASS_AFTER_18 }1{$ELSE }-1{$ENDIF }; freq: DWORD = 44100; flags: DWORD = BASS_DEVICE_LEAVEVOL; handle: int = 0);
    //
    procedure AfterConstruction(); override;
    procedure BeforeDestruction(); override;
    //
    function initialize(deviceId: int = -1; freq: DWORD = 44100; flags: DWORD = BASS_DEVICE_LEAVEVOL; win: HWND = 0; force: bool = false): bool;
    //
    function get_version(): DWORD;
    function get_versionStr(): string;
    function get_errorCode(): int;
    function get_info(out info: BASS_INFO): bool;
    function get_CPU(): int;	// 1% = 100
    //
    function get_deviceDescription(deviceNum: unsigned): string;
    function get_DSObject(obj: DWORD): pointer;
    function set_CLSID(clsid: TGUID): bool;
    //
    function set_logCurves(volume, pan: bool): bool;
    function set_bufferLength(const len: FLOAT): FLOAT;
    function set_netConfig(option, value: DWORD): DWORD;
    //
    function get_globalVolumes(out musvol, samvol, strvol: int): bool;
    function set_globalVolumes(musvol, samvol, strvol: int): bool;
    function get_volume(): int;
    function set_volume(volume: int): bool;
    //
    function start(): bool;
    function stop(): bool;
    function pause(): bool;
    function update(): bool;
    //
    function apply3D(): bool;
    function get_3DPosition(out pos, vel, front, top: BASS_3DVECTOR): bool;
    function set_3DPosition(const pos, vel, front, top: BASS_3DVECTOR): bool;
    function get_3DFactors(out distf, rollf, doppf: FLOAT): bool;
    function set_3DFactors(const distf, rollf, doppf: FLOAT): bool;
    function get_EAXParameters(out env: int; out vol, decay, damp: FLOAT): bool;
    function set_EAXParameters(env: int; const vol, decay, damp: FLOAT): bool;
    function set_3DAlgorithm(algo: DWORD): bool;
    //
    function cd_init(drive: char; flags: DWORD): bool;
    function cd_free(): bool;
    function cd_inDrive(): bool;
    function cd_play(track: DWORD; loop: bool = false; wait: bool = false): bool;
    function cd_stop(): bool;
    function cd_get_tracks(): int;
    function cd_get_trackLength(track: DWORD): DWORD;
    function cd_get_ID(id: DWORD): string;
    function cd_door(doOpen: bool): bool;
    //
    function record_get_deviceDescription(deviceId: int): string;
    function record_init(deviceId: int): bool;
    function record_free(): bool;
    function record_getInfo(out info: BASS_RECORDINFO): bool;
    function record_start(freq, flags: DWORD; proc: RECORDPROC; user: DWORD): bool;
    function record_getLineName(line: DWORD): string;
    function record_selectLine(line: DWORD; settings: DWORD): bool;
    function record_getLineInfo(line: DWORD): DWORD;
  end;


  {DP:CLASS
    Provides interface for BASS module music support.
    <BR>Requires BASS library (bass.dll)
  }
  unaBassMusic = class(unaBassConsumer)
  private
    f_ampLevel: DWORD;
    f_panSep: DWORD;
  protected
    procedure music_free();
    procedure freeResources(); override;
    procedure setHandle(value: DWORD); override;
    //
    function supportsDSP(): bool; override;
  public
    function load(const fileName: string; offset: DWORD = 0; maxLength: DWORD = 0; flags: DWORD = 0): bool; overload;
    function load(buf: pointer; len: DWORD; flags: DWORD = 0): bool; overload;
    //
    function get_name(): string;
    function get_length(playlen: bool = true): QWORD;
    function set_positionScaler(scale: DWORD): bool;
    function get_channelVol(channel: DWORD): int;
    function set_channelVol(channel, volume: DWORD): bool;
    //
    function get_ampLevel(): DWORD;
    function set_ampLevel(amp: DWORD): bool;
    function get_panSeparation(): DWORD;
    function set_panSeparation(pan: DWORD): bool;
    //
    function play(ensureBass: bool = true): bool;
    function playEx(position: int{in seconds}; flags: DWORD = BASS_MUSIC_SURROUND; reset: bool = true): bool; overload;
    function playEx(row, order: DWORD; flags: DWORD = BASS_MUSIC_SURROUND; reset: bool = false): bool; overload;
    function preBuf(len: DWORD = 0): bool;
  end;


  {DP:CLASS
    Provides interface for BASS sample support.
    <BR>Requires BASS library (bass.dll)
  }
  unaBassSample = class(unaBassConsumer)
  protected
    procedure sample_free();
    procedure freeResources(); override;
  public
    function load(const fileName: string; offset: DWORD = 0; maxLength: DWORD = 0; maxOver: DWORD = 16; flags: DWORD = BASS_SAMPLE_OVER_VOL): bool; overload;
    function load(buf: pointer; len: DWORD; maxOver: DWORD = 16; flags: DWORD = BASS_SAMPLE_OVER_VOL): bool; overload;
    //
    function createSample(buf: pointer; len: unsigned; freq, max, flags: DWORD; chans: DWORD = 0): bool;
    //
    function get_info(out info: BASS_SAMPLE): bool;
    function set_info(const info: BASS_SAMPLE): bool;
    function play(): HCHANNEL;
    function playEx(start: DWORD; freq, volume, pan: Integer; loop: bool): HCHANNEL;
    function play3D(const pos, orient, vel: BASS_3DVECTOR): HCHANNEL;
    function play3DEx(const pos, orient, vel: BASS_3DVECTOR; start: DWORD; freq, volume: Integer; loop: bool): HCHANNEL;
    function stop(handle: HSAMPLE): bool;
  end;


  {DP:CLASS
    Provides interface for BASS stream support.
    <BR>Requires BASS library (bass.dll)
  }
  unaBassStream = class(unaBassConsumer)
  protected
    procedure stream_free();
    procedure freeResources(); override;
    //
{$IFDEF BASS_AFTER_18 }
    procedure onDownloadURL(buf: pointer; len: unsigned); virtual;
{$ENDIF }
  public
    function createStream(freq, flags: DWORD; proc: pointer; user: DWORD): bool; overload;
    function createStream(const fileName: string; offset, maxLength, flags: DWORD): bool; overload;
    function createStream(const url: string; offset: DWORD; flags: DWORD; const localCopy: string = ''): bool; overload;
    function createStream(data: pointer; len, flags: DWORD): bool; overload;
    //
    function get_length(): QWORD;
    function get_filePosition(mode: DWORD): DWORD;
    function get_tags(tags: DWORD): pChar;
    //
    function play(flush: bool; flags: DWORD): bool;
    function preBuf(len: DWORD = 0): bool;
    //
    procedure closeStream();
    function isOpen(): bool;
  end;


  {DP:CLASS
    Provides interface for BASS channel support.
    <BR>Requires BASS library (bass.dll)
  }
  unaBassChannel = class(unaBassConsumer)
  protected
    procedure freeResources(); override;
  public
    function init(channel: HCHANNEL): bool;
    //
    function get_flags(): DWORD;
    function get_attributes(out freq, volume, pan: int): bool;
    function set_attributes(freq, volume, pan: int): bool;
    function get_3DAttributes(out mode: int; out min, max: FLOAT; out iangle, oangle, outvol: int): bool;
    function set_3DAttributes(const mode: int; min, max: FLOAT; iangle, oangle, outvol: int): bool;
    function get_position(orderRow: bool = false): QWORD;
    function set_position(RO: QWORD; orderRow: bool = false): bool;
    function get_3DPosition(out pos, orient, vel: BASS_3DVECTOR): bool;
    function set_3DPosition(const pos, orient, vel: BASS_3DVECTOR): bool;
    function set_EAXMix(const mix: FLOAT): bool;
    function get_EAXMix(out mix: FLOAT): bool;
    function set_slideAttributes(freq, volume, pan: Integer; time: DWORD): bool;
    function get_isSliding(): DWORD;
    //
    function stop(): bool;
    function pause(): bool;
    function resume(): bool;
    //
    function get_isActive(): DWORD;
    function get_level(): DWORD;
    function get_data(buf: pointer; len: DWORD): int;
    function get_dataAvailSize(): int;
  {$IFDEF BASS_AFTER_22 }
    function get_tags(handle: DWORD; tags: DWORD): pChar;
  {$ENDIF }
    //
    function remove_sync(sync: HSYNC): bool;
    function remove_DSP(dsp: HDSP): bool;
    function remove_link(chan: DWORD): bool;
    function remove_FX(fx: HFX): bool;
    function set_sync(atype: DWORD; param: QWORD; proc: SYNCPROC; user: DWORD): HSYNC;
    function set_DSP(proc: DSPPROC; user: DWORD): HDSP;
    function set_link(chan: DWORD): bool;
    function set_FX(etype: DWORD; priority: int = 0): HFX;
    //
    function FX_set_parameters(fx: HFX; par: pointer): bool;
    function FX_get_parameters(fx: HFX; par: pointer): bool;
  end;


  tUnaBassApplySampling = procedure(sender: tObject; rate, bits, channels: unsigned) of object;
  tUnaBassDataAvailable = procedure(sender: tObject; data: pointer; size: unsigned) of object;

  // --  --
  unaBassStreamDecoder = class(unaThread)
  private
    f_dataTimeout: int;
    f_bassStream: unaBassStream;
    f_dataStream: unaAbstractStream;
    f_onAS: tUnaBassApplySampling;
    f_onDA: tUnaBassDataAvailable;
  protected
    function execute(threadIndex: unsigned): int; override;
    procedure startOut(); override;
    //
    procedure applySampling(rate, bits, channels: unsigned); virtual;
    procedure dataAvailable(data: pointer; size: unsigned); virtual;
  public
    constructor create(bassStream: unaBassStream; dataStream: unaAbstractStream; dataTimeout: int = 1000);
    procedure BeforeDestruction(); override;
    //
    property onApplySampling: tUnaBassApplySampling read f_onAS write f_onAS;
    property onDataAvailable: tUnaBassDataAvailable read f_onDA write f_onDA;
    //
    property dataTimeout: int read f_dataTimeout write f_dataTimeout;	// ms
  end;


  {DP:CLASS
    Decoder based on BASS library
  }
  unaBassDecoder = class
  private
    f_libName: string;
    f_bass: unaBass;
    f_bassStream: unaBassStream;
    f_bassError: int;
    f_dataStream: unaMemoryStream;
    f_bassStreamThread: unaBassStreamDecoder;
  public
    constructor create(const libName: string = '');
    procedure AfterConstruction(); override;
    procedure BeforeDestruction(); override;
    //
    procedure open();
    procedure close();
    procedure updateConfig(const libName: string = '');
    procedure write(data: pointer; len: unsigned);