babaev-an/lasarus_compotents
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Стартовый пул

Browse Source
This commit is contained in:
Александр Бабаев
2024-04-02 08:46:59 +03:00
parent fd57fffd3a
commit 3bb34d000b
5591 changed files with 3291734 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

606
acs/Src/fileformats/general/flac.pas Normal file
View File

@@ -0,0 +1,606 @@
(*
this file is a part of audio components suite v 2.3.
copyright (c) 2002-2005 andrei borovsky. all rights reserved.
see the license file for more details.
you can contact me at mail@z0m3ie.de
*)
{
$Log: flac.pas,v $
Revision 1.1 2005/12/19 18:36:56 z0m3ie
*** empty log message ***
Revision 1.1 2005/09/12 22:04:53 z0m3ie
modified structure again, fileformats are now in an sperat folder.
all File In/Out classes are capsulated from TFileIn and TFileOut
Revision 1.1 2005/08/25 20:18:00 z0m3ie
Version 2.4 restructure
TCDPlayer removed (fits not in component structure)
TMP3ToWavConverter removed (fits not in component structure)
Revision 1.2 2005/08/22 20:17:01 z0m3ie
changed Headers to log
changed mail adress
}
unit flac;
{$ifdef fpc}
{$mode delphi}
{$endif}
interface
uses
{$IFDEF WINDOWS}
Windows;
{$ENDIF}
{$IFDEF LINUX}
baseunix,dl, ACS_Procs;
{$ENDIF}
var
LibFLACLoaded : Boolean = False;
const
{$IFDEF WINDOWS}
LibFLACPath = 'libFLAC.dll';
{$ENDIF}
{$IFDEF LINUX}
LibFLACPath = 'libFLAC.so*'; // libFLAC.so
{$DEFINE SEARCH_LIBS}
{$ENDIF}
FLAC__SEEKABLE_STREAM_ENCODER_OK = 0;
FLAC__SEEKABLE_STREAM_ENCODER_STREAM_ENCODER_ERROR = 1;
FLAC__SEEKABLE_STREAM_ENCODER_MEMORY_ALLOCATION_ERROR = 2;
FLAC__SEEKABLE_STREAM_ENCODER_WRITE_ERROR = 3;
FLAC__SEEKABLE_STREAM_ENCODER_READ_ERROR = 4;
FLAC__SEEKABLE_STREAM_ENCODER_SEEK_ERROR = 5;
FLAC__SEEKABLE_STREAM_ENCODER_ALREADY_INITIALIZED = 6;
FLAC__SEEKABLE_STREAM_ENCODER_INVALID_CALLBACK = 7;
FLAC__SEEKABLE_STREAM_ENCODER_INVALID_SEEKTABLE = 8;
FLAC__SEEKABLE_STREAM_ENCODER_UNINITIALIZED = 9;
FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK = 0;
FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR = 1;
FLAC__SEEKABLE_STREAM_DECODER_OK = 0;
FLAC__SEEKABLE_STREAM_DECODER_SEEKING = 1;
FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM = 2;
FLAC__SEEKABLE_STREAM_DECODER_MEMORY_ALLOCATION_ERROR = 3;
FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR = 4;
FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR = 5;
FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR = 6;
FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED = 7;
FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK = 8;
FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED = 10;
FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK = 0;
FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR = 1;
FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK = 0;
FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR = 1;
FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK = 0;
FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR = 1;
FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK = 0;
FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR = 1;
type
FLAC__byte = Byte;
PFLAC__byte = ^FLAC__byte;
FLAC__uint64 = Int64;
PFLAC__uint64 = ^FLAC__uint64;
FLAC__uint32 = LongWord;
PFLAC__uint32 = ^FLAC__uint32;
FLAC__int32 = Integer;
PFLAC__int32 = ^FLAC__int32;
PFLAC__SeekableStreamEncoder = Pointer;
PFLAC__SeekableStreamDecoder = Pointer;
FLAC__MetadataType = Integer;
PFLAC__Frame = Pointer;
FLAC__FrameHeader = packed record
blocksize : LongWord;
sample_rate : LongWord;
channels : LongWord;
channel_assignment : Integer;
bits_per_sample : LongWord;
frame_number : FLAC__uint32;
crc : Byte;
end;
FLACInfo = record
min_blocksize : LongWord;
max_blocksize : LongWord;
min_framesize : LongWord;
max_framesize : LongWord;
sample_rate : LongWord;
channels : LongWord;
bits_per_sample : LongWord;
total_samples1 : LongWord;
total_samples2 : LongWord;
end;
PFLACInfo = ^FLACInfo;
PFLAC__StreamMetadata = Pointer;
PFLAC__FrameHeader = ^FLAC__FrameHeader;
FLACIntBuf = array[0..0] of FLAC__int32;
PFLACIntBuf = ^FLACIntBuf;
FLACChannels = array[0..1] of PFLACIntBuf;
PFLACChannels = ^FLACChannels;
FLAC__SeekableStreamEncoderWriteCallback = function(encoder : PFLAC__SeekableStreamEncoder;
buffer : PFLAC__byte;
bytes,
samples,
current_frame : LongWord;
client_data : Pointer) : Integer; cdecl;
FLAC__SeekableStreamEncoderSeekCallback = function(encoder : PFLAC__SeekableStreamEncoder;
absolute_byte_offset : FLAC__uint64;
client_data : Pointer) : Integer; cdecl;
FLAC__SeekableStreamDecoderReadCallback = function(decoder : PFLAC__SeekableStreamDecoder;
buffer : PFLAC__byte;
var bytes : LongWord;
client_data : Pointer) : Integer; cdecl;
FLAC__SeekableStreamDecoderSeekCallback = function(decoder : PFLAC__SeekableStreamDecoder;
absolute_byte_offset : FLAC__uint64;
client_data : Pointer) : Integer; cdecl;
FLAC__SeekableStreamDecoderTellCallback = function(decoder : PFLAC__SeekableStreamDecoder;
var absolute_byte_offset : FLAC__uint64;
client_data : Pointer) : Integer; cdecl;
FLAC__SeekableStreamDecoderLengthCallback = function(decoder : PFLAC__SeekableStreamDecoder;
var stream_length : FLAC__uint64;
client_data : Pointer) : Integer; cdecl;
FLAC__SeekableStreamDecoderEofCallback = function(decoder : PFLAC__SeekableStreamDecoder;
client_data : Pointer) : Boolean; cdecl;
FLAC__SeekableStreamDecoderWriteCallback = function(decoder : PFLAC__SeekableStreamDecoder;
frame : PFLAC__Frame;
buffer : PFLACChannels;
client_data : Pointer) : Integer; cdecl;
FLAC__SeekableStreamDecoderMetadataCallback = procedure(decoder : PFLAC__SeekableStreamDecoder;
metadata : PFLAC__StreamMetadata;
client_data : Pointer); cdecl;
FLAC__SeekableStreamDecoderErrorCallback = procedure(decoder : PFLAC__SeekableStreamDecoder;
status : Integer;
client_data : Pointer); cdecl;
FLAC__seekable_stream_encoder_new_t = function : PFLAC__SeekableStreamEncoder; cdecl;
FLAC__seekable_stream_encoder_delete_t = procedure(encoder : PFLAC__SeekableStreamEncoder); cdecl;
FLAC__seekable_stream_encoder_set_verify_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_streamable_subset_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_do_mid_side_stereo_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_loose_mid_side_stereo_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_channels_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_bits_per_sample_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_sample_rate_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_blocksize_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_max_lpc_order_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_qlp_coeff_precision_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_do_escape_coding_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_do_exhaustive_model_search_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_min_residual_partition_order_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_max_residual_partition_order_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_rice_parameter_search_dist_t = function( encoder : PFLAC__SeekableStreamEncoder; value : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_total_samples_estimate_t = function( encoder : PFLAC__SeekableStreamEncoder; value : FLAC__uint64) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_metadata_t = function( encoder : PFLAC__SeekableStreamEncoder; metadata : Pointer; num_blocks : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_seek_callback_t = function( encoder : PFLAC__SeekableStreamEncoder; value : FLAC__SeekableStreamEncoderSeekCallback) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_write_callback_t = function( encoder : PFLAC__SeekableStreamEncoder; value : FLAC__SeekableStreamEncoderWriteCallback) : Boolean; cdecl;
FLAC__seekable_stream_encoder_set_client_data_t = function( encoder : PFLAC__SeekableStreamEncoder; value : Pointer) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_state_t = function( encoder : PFLAC__SeekableStreamEncoder) : Integer; cdecl;
FLAC__seekable_stream_encoder_get_stream_encoder_state_t = function( encoder : PFLAC__SeekableStreamEncoder) : Integer; cdecl;
FLAC__seekable_stream_encoder_get_verify_decoder_state_t = function( encoder : PFLAC__SeekableStreamEncoder) : Integer; cdecl;
FLAC__seekable_stream_encoder_get_resolved_state_string_t = function( encoder : PFLAC__SeekableStreamEncoder) : PChar; cdecl;
FLAC__seekable_stream_encoder_get_verify_decoder_error_stats_t = procedure(encoder : PFLAC__SeekableStreamEncoder; absolute_sample : PFLAC__uint64; frame_number, channel, sample : PLongWord; expected, got : FLAC__int32); cdecl;
FLAC__seekable_stream_encoder_get_verify_t = function( encoder : PFLAC__SeekableStreamEncoder) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_streamable_subset_t = function( encoder : PFLAC__SeekableStreamEncoder) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_do_mid_side_stereo_t = function( encoder : PFLAC__SeekableStreamEncoder) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_loose_mid_side_stereo_t = function( encoder : PFLAC__SeekableStreamEncoder) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_channels_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_bits_per_sample_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_sample_rate_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_blocksize_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_max_lpc_order_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_qlp_coeff_precision_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search_t = function( encoder : PFLAC__SeekableStreamEncoder) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_do_escape_coding_t = function( encoder : PFLAC__SeekableStreamEncoder) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_do_exhaustive_model_search_t = function( encoder : PFLAC__SeekableStreamEncoder) : Boolean; cdecl;
FLAC__seekable_stream_encoder_get_min_residual_partition_order_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_max_residual_partition_order_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_rice_parameter_search_dist_t = function( encoder : PFLAC__SeekableStreamEncoder) : LongWord; cdecl;
FLAC__seekable_stream_encoder_get_total_samples_estimate_t = function( encoder : PFLAC__SeekableStreamEncoder) : FLAC__uint64 cdecl;
FLAC__seekable_stream_encoder_init_t = function( encoder : PFLAC__SeekableStreamEncoder) : Integer; cdecl;
FLAC__seekable_stream_encoder_finish_t = procedure(encoder : PFLAC__SeekableStreamEncoder); cdecl;
FLAC__seekable_stream_encoder_process_t = function(encoder : PFLAC__SeekableStreamEncoder; buffer : PFLAC__int32; samples : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_encoder_process_interleaved_t = function(encoder : PFLAC__SeekableStreamEncoder; buffer : PFLAC__int32; samples : LongWord) : Boolean; cdecl;
FLAC__seekable_stream_decoder_new_t = function : PFLAC__SeekableStreamDecoder; cdecl;
FLAC__seekable_stream_decoder_delete_t = procedure(decoder : PFLAC__SeekableStreamDecoder); cdecl;
FLAC__seekable_stream_decoder_set_md5_checking_t = function( decoder : PFLAC__SeekableStreamDecoder; value : Boolean) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_read_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderReadCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_seek_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderSeekCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_tell_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderTellCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_length_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderLengthCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_eof_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderEofCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_write_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderWriteCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_metadata_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderMetadataCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_error_callback_t = function( decoder : PFLAC__SeekableStreamDecoder; value : FLAC__SeekableStreamDecoderErrorCallback) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_client_data_t = function( decoder : PFLAC__SeekableStreamDecoder; value : Pointer) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_metadata_respond_t = function( decoder : PFLAC__SeekableStreamDecoder; _type : FLAC__MetadataType) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_metadata_respond_application_t = function( decoder : PFLAC__SeekableStreamDecoder; id : PFLAC__byte) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_metadata_respond_all_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_metadata_ignore_t = function( decoder : PFLAC__SeekableStreamDecoder; _type : FLAC__MetadataType) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_metadata_ignore_application_t = function( decoder : PFLAC__SeekableStreamDecoder; id : PFLAC__byte) : Boolean; cdecl;
FLAC__seekable_stream_decoder_set_metadata_ignore_all_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_get_state_t = function( decoder : PFLAC__SeekableStreamDecoder) : Integer; cdecl;
FLAC__seekable_stream_decoder_get_stream_decoder_state_t = function( decoder : PFLAC__SeekableStreamDecoder) : Integer; cdecl;
FLAC__seekable_stream_decoder_get_resolved_state_string_t = function( decoder : PFLAC__SeekableStreamDecoder) : PChar; cdecl;
FLAC__seekable_stream_decoder_get_md5_checking_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_get_channels_t = function( decoder : PFLAC__SeekableStreamDecoder) : Integer; cdecl;
FLAC__seekable_stream_decoder_get_channel_assignment_t = function( decoder : PFLAC__SeekableStreamDecoder) : Integer; cdecl;
FLAC__seekable_stream_decoder_get_bits_per_sample_t = function( decoder : PFLAC__SeekableStreamDecoder) : LongWord; cdecl;
FLAC__seekable_stream_decoder_get_sample_rate_t = function( decoder : PFLAC__SeekableStreamDecoder) : LongWord; cdecl;
FLAC__seekable_stream_decoder_get_blocksize_t = function( decoder : PFLAC__SeekableStreamDecoder) : LongWord; cdecl;
FLAC__seekable_stream_decoder_get_decode_position_t = function( decoder : PFLAC__SeekableStreamDecoder; var position : FLAC__uint64) : Boolean; cdecl;
FLAC__seekable_stream_decoder_init_t = function( decoder : PFLAC__SeekableStreamDecoder) : Integer; cdecl;
FLAC__seekable_stream_decoder_finish_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_flush_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_reset_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_process_single_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_process_until_end_of_metadata_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_process_until_end_of_stream_t = function( decoder : PFLAC__SeekableStreamDecoder) : Boolean; cdecl;
FLAC__seekable_stream_decoder_seek_absolute_t = function( decoder : PFLAC__SeekableStreamDecoder; sample : FLAC__uint64) : Boolean; cdecl;
var
FLAC__seekable_stream_encoder_new : FLAC__seekable_stream_encoder_new_t;
FLAC__seekable_stream_encoder_delete : FLAC__seekable_stream_encoder_delete_t;
FLAC__seekable_stream_encoder_set_verify : FLAC__seekable_stream_encoder_set_verify_t;
FLAC__seekable_stream_encoder_set_streamable_subset : FLAC__seekable_stream_encoder_set_streamable_subset_t;
FLAC__seekable_stream_encoder_set_do_mid_side_stereo : FLAC__seekable_stream_encoder_set_do_mid_side_stereo_t;
FLAC__seekable_stream_encoder_set_loose_mid_side_stereo : FLAC__seekable_stream_encoder_set_loose_mid_side_stereo_t;
FLAC__seekable_stream_encoder_set_channels : FLAC__seekable_stream_encoder_set_channels_t;
FLAC__seekable_stream_encoder_set_bits_per_sample : FLAC__seekable_stream_encoder_set_bits_per_sample_t;
FLAC__seekable_stream_encoder_set_sample_rate : FLAC__seekable_stream_encoder_set_sample_rate_t;
FLAC__seekable_stream_encoder_set_blocksize : FLAC__seekable_stream_encoder_set_blocksize_t;
FLAC__seekable_stream_encoder_set_max_lpc_order : FLAC__seekable_stream_encoder_set_max_lpc_order_t;
FLAC__seekable_stream_encoder_set_qlp_coeff_precision : FLAC__seekable_stream_encoder_set_qlp_coeff_precision_t;
FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search : FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search_t;
FLAC__seekable_stream_encoder_set_do_escape_coding : FLAC__seekable_stream_encoder_set_do_escape_coding_t;
FLAC__seekable_stream_encoder_set_do_exhaustive_model_search : FLAC__seekable_stream_encoder_set_do_exhaustive_model_search_t;
FLAC__seekable_stream_encoder_set_min_residual_partition_order : FLAC__seekable_stream_encoder_set_min_residual_partition_order_t;
FLAC__seekable_stream_encoder_set_max_residual_partition_order : FLAC__seekable_stream_encoder_set_max_residual_partition_order_t;
// FLAC__seekable_stream_encoder_set_rice_parameter_search_dist : FLAC__seekable_stream_encoder_set_rice_parameter_search_dist_t;
FLAC__seekable_stream_encoder_set_total_samples_estimate : FLAC__seekable_stream_encoder_set_total_samples_estimate_t;
FLAC__seekable_stream_encoder_set_metadata : FLAC__seekable_stream_encoder_set_metadata_t;
FLAC__seekable_stream_encoder_set_seek_callback : FLAC__seekable_stream_encoder_set_seek_callback_t;
FLAC__seekable_stream_encoder_set_write_callback : FLAC__seekable_stream_encoder_set_write_callback_t;
FLAC__seekable_stream_encoder_set_client_data : FLAC__seekable_stream_encoder_set_client_data_t;
FLAC__seekable_stream_encoder_get_state : FLAC__seekable_stream_encoder_get_state_t;
FLAC__seekable_stream_encoder_get_stream_encoder_state : FLAC__seekable_stream_encoder_get_stream_encoder_state_t;
FLAC__seekable_stream_encoder_get_verify_decoder_state : FLAC__seekable_stream_encoder_get_verify_decoder_state_t;
FLAC__seekable_stream_encoder_get_resolved_state_string : FLAC__seekable_stream_encoder_get_resolved_state_string_t;
FLAC__seekable_stream_encoder_get_verify_decoder_error_stats : FLAC__seekable_stream_encoder_get_verify_decoder_error_stats_t;
FLAC__seekable_stream_encoder_get_verify : FLAC__seekable_stream_encoder_get_verify_t;
FLAC__seekable_stream_encoder_get_streamable_subset : FLAC__seekable_stream_encoder_get_streamable_subset_t;
FLAC__seekable_stream_encoder_get_do_mid_side_stereo : FLAC__seekable_stream_encoder_get_do_mid_side_stereo_t;
FLAC__seekable_stream_encoder_get_loose_mid_side_stereo : FLAC__seekable_stream_encoder_get_loose_mid_side_stereo_t;
FLAC__seekable_stream_encoder_get_channels : FLAC__seekable_stream_encoder_get_channels_t;
FLAC__seekable_stream_encoder_get_bits_per_sample : FLAC__seekable_stream_encoder_get_bits_per_sample_t;
FLAC__seekable_stream_encoder_get_sample_rate : FLAC__seekable_stream_encoder_get_sample_rate_t;
FLAC__seekable_stream_encoder_get_blocksize : FLAC__seekable_stream_encoder_get_blocksize_t;
FLAC__seekable_stream_encoder_get_max_lpc_order : FLAC__seekable_stream_encoder_get_max_lpc_order_t;
FLAC__seekable_stream_encoder_get_qlp_coeff_precision : FLAC__seekable_stream_encoder_get_qlp_coeff_precision_t;
FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search : FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search_t;
FLAC__seekable_stream_encoder_get_do_escape_coding : FLAC__seekable_stream_encoder_get_do_escape_coding_t;
FLAC__seekable_stream_encoder_get_do_exhaustive_model_search : FLAC__seekable_stream_encoder_get_do_exhaustive_model_search_t;
FLAC__seekable_stream_encoder_get_min_residual_partition_order : FLAC__seekable_stream_encoder_get_min_residual_partition_order_t;
FLAC__seekable_stream_encoder_get_max_residual_partition_order : FLAC__seekable_stream_encoder_get_max_residual_partition_order_t;
// FLAC__seekable_stream_encoder_get_rice_parameter_search_dist : FLAC__seekable_stream_encoder_get_rice_parameter_search_dist_t;
FLAC__seekable_stream_encoder_get_total_samples_estimate : FLAC__seekable_stream_encoder_get_total_samples_estimate_t;
FLAC__seekable_stream_encoder_init : FLAC__seekable_stream_encoder_init_t;
FLAC__seekable_stream_encoder_finish : FLAC__seekable_stream_encoder_finish_t;
FLAC__seekable_stream_encoder_process : FLAC__seekable_stream_encoder_process_t;
FLAC__seekable_stream_encoder_process_interleaved : FLAC__seekable_stream_encoder_process_interleaved_t;
FLAC__seekable_stream_decoder_new : FLAC__seekable_stream_decoder_new_t;
FLAC__seekable_stream_decoder_delete : FLAC__seekable_stream_decoder_delete_t;
FLAC__seekable_stream_decoder_set_md5_checking : FLAC__seekable_stream_decoder_set_md5_checking_t;
FLAC__seekable_stream_decoder_set_read_callback : FLAC__seekable_stream_decoder_set_read_callback_t;
FLAC__seekable_stream_decoder_set_seek_callback : FLAC__seekable_stream_decoder_set_seek_callback_t;
FLAC__seekable_stream_decoder_set_tell_callback : FLAC__seekable_stream_decoder_set_tell_callback_t;
FLAC__seekable_stream_decoder_set_length_callback : FLAC__seekable_stream_decoder_set_length_callback_t;
FLAC__seekable_stream_decoder_set_eof_callback : FLAC__seekable_stream_decoder_set_eof_callback_t;
FLAC__seekable_stream_decoder_set_write_callback : FLAC__seekable_stream_decoder_set_write_callback_t;
FLAC__seekable_stream_decoder_set_metadata_callback : FLAC__seekable_stream_decoder_set_metadata_callback_t;
FLAC__seekable_stream_decoder_set_error_callback : FLAC__seekable_stream_decoder_set_error_callback_t;
FLAC__seekable_stream_decoder_set_client_data : FLAC__seekable_stream_decoder_set_client_data_t;
FLAC__seekable_stream_decoder_set_metadata_respond : FLAC__seekable_stream_decoder_set_metadata_respond_t;
FLAC__seekable_stream_decoder_set_metadata_respond_application : FLAC__seekable_stream_decoder_set_metadata_respond_application_t;
FLAC__seekable_stream_decoder_set_metadata_respond_all : FLAC__seekable_stream_decoder_set_metadata_respond_all_t;
FLAC__seekable_stream_decoder_set_metadata_ignore : FLAC__seekable_stream_decoder_set_metadata_ignore_t;
FLAC__seekable_stream_decoder_set_metadata_ignore_application : FLAC__seekable_stream_decoder_set_metadata_ignore_application_t;
FLAC__seekable_stream_decoder_set_metadata_ignore_all : FLAC__seekable_stream_decoder_set_metadata_ignore_all_t;
FLAC__seekable_stream_decoder_get_state : FLAC__seekable_stream_decoder_get_state_t;
FLAC__seekable_stream_decoder_get_stream_decoder_state : FLAC__seekable_stream_decoder_get_stream_decoder_state_t;
FLAC__seekable_stream_decoder_get_resolved_state_string : FLAC__seekable_stream_decoder_get_resolved_state_string_t;
FLAC__seekable_stream_decoder_get_md5_checking : FLAC__seekable_stream_decoder_get_md5_checking_t;
FLAC__seekable_stream_decoder_get_channels : FLAC__seekable_stream_decoder_get_channels_t;
FLAC__seekable_stream_decoder_get_channel_assignment : FLAC__seekable_stream_decoder_get_channel_assignment_t;
FLAC__seekable_stream_decoder_get_bits_per_sample : FLAC__seekable_stream_decoder_get_bits_per_sample_t;
FLAC__seekable_stream_decoder_get_sample_rate : FLAC__seekable_stream_decoder_get_sample_rate_t;
FLAC__seekable_stream_decoder_get_blocksize : FLAC__seekable_stream_decoder_get_blocksize_t;
FLAC__seekable_stream_decoder_get_decode_position : FLAC__seekable_stream_decoder_get_decode_position_t;
FLAC__seekable_stream_decoder_init : FLAC__seekable_stream_decoder_init_t;
FLAC__seekable_stream_decoder_finish : FLAC__seekable_stream_decoder_finish_t;
FLAC__seekable_stream_decoder_flush : FLAC__seekable_stream_decoder_flush_t;
FLAC__seekable_stream_decoder_reset : FLAC__seekable_stream_decoder_reset_t;
FLAC__seekable_stream_decoder_process_single : FLAC__seekable_stream_decoder_process_single_t;
FLAC__seekable_stream_decoder_process_until_end_of_metadata : FLAC__seekable_stream_decoder_process_until_end_of_metadata_t;
FLAC__seekable_stream_decoder_process_until_end_of_stream : FLAC__seekable_stream_decoder_process_until_end_of_stream_t;
FLAC__seekable_stream_decoder_seek_absolute : FLAC__seekable_stream_decoder_seek_absolute_t;
implementation
{$IFDEF WIN32}
var
Libhandle : HMODULE;
initialization
Libhandle := LoadLibraryEx(LibFLACPath, 0, 0);
if Libhandle <> 0 then
begin
LibFLACLoaded := True;
FLAC__seekable_stream_encoder_new := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_new');
FLAC__seekable_stream_encoder_delete := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_delete');
FLAC__seekable_stream_encoder_set_verify := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_verify');
FLAC__seekable_stream_encoder_set_streamable_subset := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_streamable_subset');
FLAC__seekable_stream_encoder_set_do_mid_side_stereo := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_do_mid_side_stereo');
FLAC__seekable_stream_encoder_set_loose_mid_side_stereo := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_loose_mid_side_stereo');
FLAC__seekable_stream_encoder_set_channels := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_channels');
FLAC__seekable_stream_encoder_set_bits_per_sample := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_bits_per_sample');
FLAC__seekable_stream_encoder_set_sample_rate := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_sample_rate');
FLAC__seekable_stream_encoder_set_blocksize := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_blocksize');
FLAC__seekable_stream_encoder_set_max_lpc_order := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_max_lpc_order');
FLAC__seekable_stream_encoder_set_qlp_coeff_precision := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_qlp_coeff_precision');
FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search');
FLAC__seekable_stream_encoder_set_do_escape_coding := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_do_escape_coding');
FLAC__seekable_stream_encoder_set_do_exhaustive_model_search := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_do_exhaustive_model_search');
FLAC__seekable_stream_encoder_set_min_residual_partition_order := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_min_residual_partition_order');
FLAC__seekable_stream_encoder_set_max_residual_partition_order := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_max_residual_partition_order');
// FLAC__seekable_stream_encoder_set_rice_parameter_search_dist := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_rice_parameter_search_dist');
FLAC__seekable_stream_encoder_set_total_samples_estimate := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_total_samples_estimate');
FLAC__seekable_stream_encoder_set_metadata := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_metadata');
FLAC__seekable_stream_encoder_set_seek_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_seek_callback');
FLAC__seekable_stream_encoder_set_write_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_write_callback');
FLAC__seekable_stream_encoder_set_client_data := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_set_client_data');
FLAC__seekable_stream_encoder_get_state := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_state');
FLAC__seekable_stream_encoder_get_stream_encoder_state := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_stream_encoder_state');
FLAC__seekable_stream_encoder_get_verify_decoder_state := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_verify_decoder_state');
FLAC__seekable_stream_encoder_get_resolved_state_string := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_resolved_state_string');
FLAC__seekable_stream_encoder_get_verify_decoder_error_stats := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_verify_decoder_error_stats');
FLAC__seekable_stream_encoder_get_verify := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_verify');
FLAC__seekable_stream_encoder_get_streamable_subset := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_streamable_subset');
FLAC__seekable_stream_encoder_get_do_mid_side_stereo := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_do_mid_side_stereo');
FLAC__seekable_stream_encoder_get_loose_mid_side_stereo := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_loose_mid_side_stereo');
FLAC__seekable_stream_encoder_get_channels := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_channels');
FLAC__seekable_stream_encoder_get_bits_per_sample := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_bits_per_sample');
FLAC__seekable_stream_encoder_get_sample_rate := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_sample_rate');
FLAC__seekable_stream_encoder_get_blocksize := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_blocksize');
FLAC__seekable_stream_encoder_get_max_lpc_order := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_max_lpc_order');
FLAC__seekable_stream_encoder_get_qlp_coeff_precision := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_qlp_coeff_precision');
FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search');
FLAC__seekable_stream_encoder_get_do_escape_coding := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_do_escape_coding');
FLAC__seekable_stream_encoder_get_do_exhaustive_model_search := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_do_exhaustive_model_search');
FLAC__seekable_stream_encoder_get_min_residual_partition_order := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_min_residual_partition_order');
FLAC__seekable_stream_encoder_get_max_residual_partition_order := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_max_residual_partition_order');
// FLAC__seekable_stream_encoder_get_rice_parameter_search_dist := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_rice_parameter_search_dist');
FLAC__seekable_stream_encoder_get_total_samples_estimate := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_get_total_samples_estimate');
FLAC__seekable_stream_encoder_init := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_init');
FLAC__seekable_stream_encoder_finish := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_finish');
FLAC__seekable_stream_encoder_process := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_process');
FLAC__seekable_stream_encoder_process_interleaved := GetProcAddress(Libhandle, 'FLAC__seekable_stream_encoder_process_interleaved');
FLAC__seekable_stream_decoder_new := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_new');
FLAC__seekable_stream_decoder_delete := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_delete');
FLAC__seekable_stream_decoder_set_md5_checking := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_md5_checking');
FLAC__seekable_stream_decoder_set_read_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_read_callback');
FLAC__seekable_stream_decoder_set_seek_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_seek_callback');
FLAC__seekable_stream_decoder_set_tell_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_tell_callback');
FLAC__seekable_stream_decoder_set_length_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_length_callback');
FLAC__seekable_stream_decoder_set_eof_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_eof_callback');
FLAC__seekable_stream_decoder_set_write_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_write_callback');
FLAC__seekable_stream_decoder_set_metadata_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_callback');
FLAC__seekable_stream_decoder_set_error_callback := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_error_callback');
FLAC__seekable_stream_decoder_set_client_data := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_client_data');
FLAC__seekable_stream_decoder_set_metadata_respond := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_respond');
FLAC__seekable_stream_decoder_set_metadata_respond_application := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_respond_application');
FLAC__seekable_stream_decoder_set_metadata_respond_all := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_respond_all');
FLAC__seekable_stream_decoder_set_metadata_ignore := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_ignore');
FLAC__seekable_stream_decoder_set_metadata_ignore_application := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_ignore_application');
FLAC__seekable_stream_decoder_set_metadata_ignore_all := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_ignore_all');
FLAC__seekable_stream_decoder_get_state := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_state');
FLAC__seekable_stream_decoder_get_stream_decoder_state := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_stream_decoder_state');
FLAC__seekable_stream_decoder_get_resolved_state_string := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_resolved_state_string');
FLAC__seekable_stream_decoder_get_md5_checking := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_md5_checking');
FLAC__seekable_stream_decoder_get_channels := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_channels');
FLAC__seekable_stream_decoder_get_channel_assignment := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_channel_assignment');
FLAC__seekable_stream_decoder_get_bits_per_sample := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_bits_per_sample');
FLAC__seekable_stream_decoder_get_sample_rate := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_sample_rate');
FLAC__seekable_stream_decoder_get_blocksize := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_blocksize');
FLAC__seekable_stream_decoder_get_decode_position := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_get_decode_position');
FLAC__seekable_stream_decoder_init := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_init');
FLAC__seekable_stream_decoder_finish := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_finish');
FLAC__seekable_stream_decoder_flush := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_flush');
FLAC__seekable_stream_decoder_reset := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_reset');
FLAC__seekable_stream_decoder_process_single := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_process_single');
FLAC__seekable_stream_decoder_process_until_end_of_metadata := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_process_until_end_of_metadata');
FLAC__seekable_stream_decoder_process_until_end_of_stream := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_process_until_end_of_stream');
FLAC__seekable_stream_decoder_seek_absolute := GetProcAddress(Libhandle, 'FLAC__seekable_stream_decoder_seek_absolute');
end;
finalization
if Libhandle <> 0 then FreeLibrary(Libhandle);
{$ENDIF}
{$IFDEF LINUX}
var
Libhandle : Pointer;
{$IFDEF SEARCH_LIBS}
Path : String;
{$ENDIF}
initialization
{$IFDEF SEARCH_LIBS}
Libhandle := nil;
Path := FindLibs(LibFLACPath);
if Path <> '' then Libhandle := dlopen(@Path[1], RTLD_NOW or RTLD_GLOBAL);
{$ELSE}
Libhandle := dlopen(LibFLACPath, RTLD_NOW or RTLD_GLOBAL);
{$ENDIF}
if Libhandle <> nil then
begin
LibFLACLoaded := True;
FLAC__seekable_stream_encoder_new := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_new');
FLAC__seekable_stream_encoder_delete := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_delete');
FLAC__seekable_stream_encoder_set_verify := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_verify');
FLAC__seekable_stream_encoder_set_streamable_subset := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_streamable_subset');
FLAC__seekable_stream_encoder_set_do_mid_side_stereo := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_do_mid_side_stereo');
FLAC__seekable_stream_encoder_set_loose_mid_side_stereo := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_loose_mid_side_stereo');
FLAC__seekable_stream_encoder_set_channels := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_channels');
FLAC__seekable_stream_encoder_set_bits_per_sample := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_bits_per_sample');
FLAC__seekable_stream_encoder_set_sample_rate := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_sample_rate');
FLAC__seekable_stream_encoder_set_blocksize := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_blocksize');
FLAC__seekable_stream_encoder_set_max_lpc_order := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_max_lpc_order');
FLAC__seekable_stream_encoder_set_qlp_coeff_precision := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_qlp_coeff_precision');
FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search');
FLAC__seekable_stream_encoder_set_do_escape_coding := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_do_escape_coding');
FLAC__seekable_stream_encoder_set_do_exhaustive_model_search := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_do_exhaustive_model_search');
FLAC__seekable_stream_encoder_set_min_residual_partition_order := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_min_residual_partition_order');
FLAC__seekable_stream_encoder_set_max_residual_partition_order := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_max_residual_partition_order');
// FLAC__seekable_stream_encoder_set_rice_parameter_search_dist := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_rice_parameter_search_dist');
FLAC__seekable_stream_encoder_set_total_samples_estimate := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_total_samples_estimate');
FLAC__seekable_stream_encoder_set_metadata := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_metadata');
FLAC__seekable_stream_encoder_set_seek_callback := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_seek_callback');
FLAC__seekable_stream_encoder_set_write_callback := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_write_callback');
FLAC__seekable_stream_encoder_set_client_data := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_set_client_data');
FLAC__seekable_stream_encoder_get_state := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_state');
FLAC__seekable_stream_encoder_get_stream_encoder_state := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_stream_encoder_state');
FLAC__seekable_stream_encoder_get_verify_decoder_state := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_verify_decoder_state');
FLAC__seekable_stream_encoder_get_resolved_state_string := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_resolved_state_string');
FLAC__seekable_stream_encoder_get_verify_decoder_error_stats := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_verify_decoder_error_stats');
FLAC__seekable_stream_encoder_get_verify := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_verify');
FLAC__seekable_stream_encoder_get_streamable_subset := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_streamable_subset');
FLAC__seekable_stream_encoder_get_do_mid_side_stereo := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_do_mid_side_stereo');
FLAC__seekable_stream_encoder_get_loose_mid_side_stereo := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_loose_mid_side_stereo');
FLAC__seekable_stream_encoder_get_channels := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_channels');
FLAC__seekable_stream_encoder_get_bits_per_sample := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_bits_per_sample');
FLAC__seekable_stream_encoder_get_sample_rate := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_sample_rate');
FLAC__seekable_stream_encoder_get_blocksize := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_blocksize');
FLAC__seekable_stream_encoder_get_max_lpc_order := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_max_lpc_order');
FLAC__seekable_stream_encoder_get_qlp_coeff_precision := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_qlp_coeff_precision');
FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_do_qlp_coeff_prec_search');
FLAC__seekable_stream_encoder_get_do_escape_coding := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_do_escape_coding');
FLAC__seekable_stream_encoder_get_do_exhaustive_model_search := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_do_exhaustive_model_search');
FLAC__seekable_stream_encoder_get_min_residual_partition_order := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_min_residual_partition_order');
FLAC__seekable_stream_encoder_get_max_residual_partition_order := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_max_residual_partition_order');
// FLAC__seekable_stream_encoder_get_rice_parameter_search_dist := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_rice_parameter_search_dist');
FLAC__seekable_stream_encoder_get_total_samples_estimate := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_get_total_samples_estimate');
FLAC__seekable_stream_encoder_init := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_init');
FLAC__seekable_stream_encoder_finish := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_finish');
FLAC__seekable_stream_encoder_process := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_process');
FLAC__seekable_stream_encoder_process_interleaved := dlsym(Libhandle, 'FLAC__seekable_stream_encoder_process_interleaved');
FLAC__seekable_stream_decoder_new := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_new');
FLAC__seekable_stream_decoder_delete := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_delete');
FLAC__seekable_stream_decoder_set_md5_checking := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_md5_checking');
FLAC__seekable_stream_decoder_set_read_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_read_callback');
FLAC__seekable_stream_decoder_set_seek_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_seek_callback');
FLAC__seekable_stream_decoder_set_tell_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_tell_callback');
FLAC__seekable_stream_decoder_set_length_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_length_callback');
FLAC__seekable_stream_decoder_set_eof_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_eof_callback');
FLAC__seekable_stream_decoder_set_write_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_write_callback');
FLAC__seekable_stream_decoder_set_metadata_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_callback');
FLAC__seekable_stream_decoder_set_error_callback := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_error_callback');
FLAC__seekable_stream_decoder_set_client_data := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_client_data');
FLAC__seekable_stream_decoder_set_metadata_respond := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_respond');
FLAC__seekable_stream_decoder_set_metadata_respond_application := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_respond_application');
FLAC__seekable_stream_decoder_set_metadata_respond_all := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_respond_all');
FLAC__seekable_stream_decoder_set_metadata_ignore := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_ignore');
FLAC__seekable_stream_decoder_set_metadata_ignore_application := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_ignore_application');
FLAC__seekable_stream_decoder_set_metadata_ignore_all := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_set_metadata_ignore_all');
FLAC__seekable_stream_decoder_get_state := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_state');
FLAC__seekable_stream_decoder_get_stream_decoder_state := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_stream_decoder_state');
FLAC__seekable_stream_decoder_get_resolved_state_string := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_resolved_state_string');
FLAC__seekable_stream_decoder_get_md5_checking := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_md5_checking');
FLAC__seekable_stream_decoder_get_channels := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_channels');
FLAC__seekable_stream_decoder_get_channel_assignment := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_channel_assignment');
FLAC__seekable_stream_decoder_get_bits_per_sample := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_bits_per_sample');
FLAC__seekable_stream_decoder_get_sample_rate := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_sample_rate');
FLAC__seekable_stream_decoder_get_blocksize := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_blocksize');
FLAC__seekable_stream_decoder_get_decode_position := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_get_decode_position');
FLAC__seekable_stream_decoder_init := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_init');
FLAC__seekable_stream_decoder_finish := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_finish');
FLAC__seekable_stream_decoder_flush := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_flush');
FLAC__seekable_stream_decoder_reset := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_reset');
FLAC__seekable_stream_decoder_process_single := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_process_single');
FLAC__seekable_stream_decoder_process_until_end_of_metadata := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_process_until_end_of_metadata');
FLAC__seekable_stream_decoder_process_until_end_of_stream := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_process_until_end_of_stream');
FLAC__seekable_stream_decoder_seek_absolute := dlsym(Libhandle, 'FLAC__seekable_stream_decoder_seek_absolute');
end;
finalization
if Libhandle <> nil then dlclose(Libhandle);
{$ENDIF}
end.

1058
acs/Src/fileformats/general/lame.pas Normal file
View File

File diff suppressed because it is too large Load Diff

297
acs/Src/fileformats/general/mad.pas Normal file
View File

@@ -0,0 +1,297 @@
(*
this file is a part of audio components suite v 2.3.
copyright (c) 2002-2005 andrei borovsky. all rights reserved.
see the license file for more details.
you can contact me at mail@z0m3ie.de
*)
{
$Log: mad.pas,v $
Revision 1.2 2006/08/03 17:31:09 z0m3ie
*** empty log message ***
Revision 1.1 2005/12/19 18:36:56 z0m3ie
*** empty log message ***
Revision 1.1 2005/09/12 22:04:53 z0m3ie
modified structure again, fileformats are now in an sperat folder.
all File In/Out classes are capsulated from TFileIn and TFileOut
Revision 1.1 2005/08/25 20:18:00 z0m3ie
Version 2.4 restructure
TCDPlayer removed (fits not in component structure)
TMP3ToWavConverter removed (fits not in component structure)
Revision 1.2 2005/08/22 20:17:01 z0m3ie
changed Headers to log
changed mail adress
}
unit mad;
{$ifdef fpc}
{$mode delphi}
{$endif}
interface
uses
{$IFDEF WIN32}
Windows;
{$ENDIF}
{$IFDEF LINUX}
baseunix,dl, ACS_Procs;
{$ENDIF}
const
{$IFDEF WIN32}
MADLibPath = 'MADLib.dll';
{$ENDIF}
{$IFDEF LINUX}
MADLibPath = 'libmad.so*'; // libmad.so
{$DEFINE SEARCH_LIBS}
{$ENDIF}
var
MADLibLoaded : Boolean = False;
type
mad_bitptr = packed record
b : PChar;
Cache, Left : Word;
end;
mad_stream = packed record
buffer : Pointer;
bufend : Pointer;
skiplen : LongWord;
sync : Integer;
freerate : LongWord;
this_frame : Pointer;
next_frame : Pointer;
ptr : mad_bitptr;
anc_ptr : mad_bitptr;
anc_bitlen : LongWord;
main_data : Pointer;
md_len : LongWord;
options : Integer;
error : Integer;
end;
p_mad_stream = ^mad_stream;
mad_timer_t = packed record
seconds : Integer;
fraction : LongWord;
end;
mad_header = packed record
layer : Integer;
mode : Integer;
mode_extension : Integer;
emphasis : Integer;
bitrate : LongWord;
samplerate : LongWord;
crc_check : Word;
crc_target : Word;
flags : Integer;
private_bits : Integer;
duration : mad_timer_t;
end;
p_mad_header = ^mad_header;
mad_frame = packed record
header : mad_header;
options : Integer;
sbsample : packed array[0..1, 0..35, 0..31] of Integer;
overlap : Pointer;
end;
p_mad_frame = ^mad_frame;
mad_pcm = packed record
samplerate : LongWord;
channels : Word;
length : Word;
samples : packed array [0..1, 0..1151] of Integer;
end;
p_mad_pcm = ^mad_pcm;
mad_synth = packed record
filter : array[0..1, 0..1, 0..1, 0..15, 0..7] of Integer;
phase : LongWord;
pcm : mad_pcm;
end;
async_struct = packed record
pid : LongWord;
_in : Integer;
_out : Integer;
end;
sync_struct = packed record
stream : mad_stream;
frame : mad_frame;
synth : mad_synth;
end;
p_sync_struct = ^sync_struct;
TInputFunc = function(CData : Pointer; Stream : p_mad_stream) : Integer; cdecl;
THeaderFunc = function(CData : Pointer; Header : p_mad_header) : Integer; cdecl;
TFilterFunc = function(CData : Pointer; Frame : p_mad_frame) : Integer; cdecl;
TOutputFunc = function(CData : Pointer; Header : p_mad_header; pcm : p_mad_pcm) : Integer; cdecl;
TErrorFunc = function(CData : Pointer; Stream : p_mad_stream; Frame : p_mad_frame) : Integer; cdecl;
TMessageFunc = function(P1, P2 : Pointer; var l : LongWord) : Integer; cdecl;
mad_decoder = packed record
mode : Integer;
options : Integer;
async : async_struct;
sync : p_sync_struct;
data : Pointer;
InputFunc : TInputFunc;
HeaderFunc : THeaderFunc;
FilterFunc : TFilterFunc;
OutputFunc : TOutputFunc;
ErrorFunc : TErrorFunc;
MessageFunc : TMessageFunc;
end;
p_mad_decoder = ^mad_decoder;
const
MAD_F_FRACBITS = 28;
MAD_F_ONE = $10000000;
MAD_FLOW_CONTINUE = $0;
MAD_FLOW_STOP = $10;
MAD_FLOW_BREAK = $11;
MAD_FLOW_IGNORE = $20;
MAD_DECODER_MODE_SYNC = 0;
MAD_DECODER_MODE_ASYNC = 1;
type
mad_decoder_init_t = procedure(mad_decoder : p_mad_decoder;
CData : Pointer;
InputFunc : TInputFunc;
HeaderFunc : THeaderFunc;
FilterFunc : TFilterFunc;
OutputFunc : TOutputFunc;
ErrorFunc : TErrorFunc;
MessageFunc : TMessageFunc); cdecl;
mad_decoder_finish_t = function(mad_decoder : p_mad_decoder) : Integer; cdecl;
mad_decoder_run_t = function(mad_decoder : p_mad_decoder; mad_decoder_mode : Integer) : Integer; cdecl;
mad_decoder_message_t = function(mad_decoder : p_mad_decoder; P : Pointer; var l : LongWord) : Integer; cdecl;
mad_stream_buffer_t = procedure(MadStream : p_mad_stream; Data : Pointer; l : LongWord); cdecl;
mad_stream_skip_t = procedure(MadStream : p_mad_stream; Skip : LongWord); cdecl;
mad_stream_sync_t = function(MadStream : p_mad_stream) : Integer; cdecl;
var
mad_decoder_init: mad_decoder_init_t;
mad_decoder_finish : mad_decoder_finish_t;
mad_decoder_run : mad_decoder_run_t;
mad_decoder_message : mad_decoder_message_t;
mad_stream_buffer : mad_stream_buffer_t;
mad_stream_skip : mad_stream_skip_t;
mad_stream_sync : mad_stream_sync_t;
implementation
{$IFDEF WIN32}
var
Libhandle : HMODULE;
initialization
Libhandle := LoadLibraryEx(MADLibPath, 0, 0);
if Libhandle <> 0 then
begin
MADLibLoaded := True;
mad_decoder_init := GetProcAddress(Libhandle, 'mad_decoder_init');
mad_decoder_finish := GetProcAddress(Libhandle, 'mad_decoder_finish');
mad_decoder_run := GetProcAddress(Libhandle, 'mad_decoder_run');
mad_decoder_message := GetProcAddress(Libhandle, 'mad_decoder_message');
mad_stream_buffer := GetProcAddress(Libhandle, 'mad_stream_buffer');
mad_stream_skip := GetProcAddress(Libhandle, 'mad_stream_skip');
mad_stream_sync := GetProcAddress(Libhandle, 'mad_stream_sync');
end;
finalization
if Libhandle <> 0 then FreeLibrary(Libhandle);
{$ENDIF}
{$IFDEF LINUX}
var
Libhandle : Pointer;
{$IFDEF SEARCH_LIBS}
Path : String;
{$ENDIF}
initialization
{$IFDEF SEARCH_LIBS}
Libhandle := nil;
Path := FindLibs(MADLibPath);
if Path <> '' then Libhandle := dlopen(@Path[1], RTLD_NOW or RTLD_GLOBAL);
{$ELSE}
Libhandle := dlopen(MADLibPath, RTLD_NOW or RTLD_GLOBAL);
{$ENDIF}
if Libhandle <> nil then
begin
MADLibLoaded := True;
mad_decoder_init := dlsym(Libhandle, 'mad_decoder_init');
mad_decoder_finish := dlsym(Libhandle, 'mad_decoder_finish');
mad_decoder_run := dlsym(Libhandle, 'mad_decoder_run');
mad_decoder_message := dlsym(Libhandle, 'mad_decoder_message');
mad_stream_buffer := dlsym(Libhandle, 'mad_stream_buffer');
mad_stream_skip := dlsym(Libhandle, 'mad_stream_skip');
mad_stream_sync := dlsym(Libhandle, 'mad_stream_sync');
end;
finalization
if Libhandle <> nil then dlclose(Libhandle);
{$ENDIF}
end.

535
acs/Src/fileformats/general/ogg.pas Normal file
View File

@@ -0,0 +1,535 @@
(*
delphi/kylix headers for oggvorbis software codec.
translated from ogg.h and os_types.h headers
by andrei borovsky, acs@compiler4.net
the original c/c++ headers and libraries (c) copyright 1994-2001
by the xiphophorus company http://www.xiph.org/
*)
{
$Log: ogg.pas,v $
Revision 1.4 2005/12/29 20:46:00 z0m3ie
fixed some problems with vorbis in lazarus
Revision 1.3 2005/12/19 18:36:56 z0m3ie
*** empty log message ***
Revision 1.1 2005/09/12 22:04:53 z0m3ie
modified structure again, fileformats are now in an sperat folder.
all File In/Out classes are capsulated from TFileIn and TFileOut
Revision 1.1 2005/08/25 20:18:00 z0m3ie
Version 2.4 restructure
TCDPlayer removed (fits not in component structure)
TMP3ToWavConverter removed (fits not in component structure)
Revision 1.2 2005/08/22 20:17:01 z0m3ie
changed Headers to log
changed mail adress
}
unit ogg;
{$ifdef fpc}
{$mode delphi}
{$endif}
interface
uses
ACS_Procs,
{$IFDEF LINUX}
baseunix,dl;
{$ENDIF}
{$IFDEF WINDOWS}
Windows;
{$ENDIF}
type
(* Type declarations from os_types.h header with
some Delphi-specific types added *)
OGG_INT64_T = int64;
POGG_INT64_T = ^OGG_INT64_T;
OGG_INT32_T = Integer;
OGG_UINT32_T = LongWord;
OGG_INT16_T = SmallInt; // Word ?
(* Note by AB: The following three type declarations,
strange as they seem, are required to make C
pointer/array stuff work in Delphi/Kylix.
See TVorbisOut class for details. *)
FLOAT_T = array[0..0] of Single;
PFLOAT = ^FLOAT_T;
PPFLOAT = ^PFLOAT;
// Type declarations from ogg.h header
POGGPACK_BUFFER = ^OGGPACK_BUFFER;
OGGPACK_BUFFER = record
endbyte: LongInt;
endbit: Integer;
buffer: PByte;
ptr: PByte;
storage: LongInt;
end;
// ogg_page is used to encapsulate the data in one Ogg bitstream page
OGG_PAGE = record
header: PByte;
header_len: LongInt;
body: PByte;
body_len: LongInt;
end;
(* ogg_stream_state contains the current encode/decode state of a logical
Ogg bitstream *)
OGG_STREAM_STATE = record
body_data: PByte; // bytes from packet bodies
body_storage: LongInt; // storage elements allocated
body_fill: LongInt; // elements stored; fill mark
body_returned: LongInt; // elements of fill returned
lacing_vals: PInteger; // The values that will go to the segment table
granule_vals: POGG_INT64_T; (* granulepos values for headers. Not compact
this way, but it is simple coupled to the
lacing fifo *)
lacing_storage: LongInt;
lacing_fill: LongInt;
lacing_packet: LongInt;
lacing_returned: LongInt;
header: array[0..281] of Byte; // working space for header encode
header_fill: Integer;
e_o_s: Integer; (* set when we have buffered the last packet in the
logical bitstream *)
b_o_s: Integer; (* set after we've written the initial page
of a logical bitstream *)
serialno: LongInt;
pageno: LongInt;
packetno: OGG_INT64_T;
(* sequence number for decode; the framing
knows where there's a hole in the data,
but we need coupling so that the codec
(which is in a seperate abstraction
layer) also knows about the gap *)
granulepos: OGG_INT64_T;
end;
(* ogg_packet is used to encapsulate the data and metadata belonging
to a single raw Ogg/Vorbis packet *)
POGG_PACKET = ^OGG_PACKET;
OGG_PACKET = record
packet: PByte;
bytes: LongInt;
b_o_s: LongInt;
e_o_s: LongInt;
granulepos: OGG_INT64_T;
packetno: OGG_INT64_T;
(* sequence number for decode; the framing
knows where there's a hole in the data,
but we need coupling so that the codec
(which is in a seperate abstraction
layer) also knows about the gap *)
end;
OGG_SYNC_STATE = record
data: PByte;
storage: Integer;
fill: Integer;
returned: Integer;
unsynced: Integer;
headerbytes: Integer;
bodybytes: Integer;
end;
const
{$IFDEF LINUX}
LiboggPath = 'libogg.so*'; // '/usr/lib/libogg.so';
{$DEFINE SEARCH_LIBS}
{$ENDIF}
{$IFDEF WINDOWS}
LiboggPath = 'ogg.dll';
{$ENDIF}
var
LiboggLoaded : Boolean = False;
type
// Ogg BITSTREAM PRIMITIVES: bitstream
oggpack_writeinit_t = procedure(var b: OGGPACK_BUFFER); cdecl;
oggpack_reset_t = procedure(var b: OGGPACK_BUFFER); cdecl;
oggpack_writeclear_t = procedure(var b: OGGPACK_BUFFER); cdecl;
oggpack_readinit_t = procedure(var b: OGGPACK_BUFFER;
buf: PByte;
bytes: Integer); cdecl;
oggpack_write_t = procedure(var b: OGGPACK_BUFFER;
value: LongInt;
bits: Integer); cdecl;
oggpack_look_t = function(var b: OGGPACK_BUFFER;
bits: Integer): LongInt; cdecl;
oggpack_look_huff_t = function(var b: OGGPACK_BUFFER;
bits: Integer): LongInt; cdecl;
oggpack_look1_t = function(var b: OGGPACK_BUFFER): LongInt; cdecl;
oggpack_adv_t = procedure(var b: OGGPACK_BUFFER;
bits: Integer); cdecl;
oggpack_adv_huff_t = function(var b: OGGPACK_BUFFER;
bits: Integer): Integer; cdecl;
oggpack_adv1_t = procedure(var b: OGGPACK_BUFFER); cdecl;
oggpack_read_t = function(var b: OGGPACK_BUFFER;
bits: Integer): LongInt; cdecl;
oggpack_read1_t = function(var b: OGGPACK_BUFFER): LongInt; cdecl;
oggpack_bytes_t = function(var b: OGGPACK_BUFFER): LongInt; cdecl;
oggpack_bits_t = function(var b: OGGPACK_BUFFER): LongInt; cdecl;
oggpack_get_buffer_t = function(var b: OGGPACK_BUFFER): PByte; cdecl;
// Ogg BITSTREAM PRIMITIVES: encoding
ogg_stream_packetin_t = function(var os: OGG_STREAM_STATE;
var op: OGG_PACKET): Integer; cdecl;
ogg_stream_pageout_t = function(var os: OGG_STREAM_STATE;
var og: OGG_PAGE): Integer; cdecl;
ogg_stream_flush_t = function(var os: OGG_STREAM_STATE;
var og: OGG_PAGE): Integer; cdecl;
// Ogg BITSTREAM PRIMITIVES: decoding
ogg_sync_init_t = function(var oy: OGG_SYNC_STATE): Integer; cdecl;
ogg_sync_clear_t = function(var oy: OGG_SYNC_STATE): Integer; cdecl;
ogg_sync_reset_t = function(var oy: OGG_SYNC_STATE): Integer; cdecl;
ogg_sync_destroy_t = function(var oy: OGG_SYNC_STATE): Integer; cdecl;
ogg_sync_buffer_t = function(var oy: OGG_SYNC_STATE;
size: LongInt): PChar; cdecl;
ogg_sync_wrote_t = function(var oy: OGG_SYNC_STATE;
bytes: LongInt): Integer; cdecl;
ogg_sync_pageseek_t = function(var oy: OGG_SYNC_STATE;
var og: OGG_PAGE): LongInt; cdecl;
ogg_sync_pageout_t = function(var oy: OGG_SYNC_STATE;
var og: OGG_PAGE): Integer; cdecl;
ogg_stream_pagein_t = function(var os: OGG_STREAM_STATE;
var og: OGG_PAGE): Integer; cdecl;
ogg_stream_packetout_t = function(var os: OGG_STREAM_STATE;
var op: OGG_PACKET): Integer; cdecl;
ogg_stream_packetpeek_t = function(var os: OGG_STREAM_STATE;
var op: OGG_PACKET): Integer; cdecl;
// Ogg BITSTREAM PRIMITIVES: general
ogg_stream_init_t = function(var os: OGG_STREAM_STATE;
serialno: Integer): Integer; cdecl;
ogg_stream_clear_t = function(var os: OGG_STREAM_STATE): Integer; cdecl;
ogg_stream_reset_t = function(var os: OGG_STREAM_STATE): Integer; cdecl;
ogg_stream_destroy_t = function(var os: OGG_STREAM_STATE): Integer; cdecl;
ogg_stream_eos_t = function(var os: OGG_STREAM_STATE): Integer; cdecl;
ogg_page_checksum_set_t = procedure(var og: OGG_PAGE); cdecl;
ogg_page_version_t = function(var og: OGG_PAGE): Integer; cdecl;
ogg_page_continued_t = function(var og: OGG_PAGE): Integer; cdecl;
ogg_page_bos_t = function(var og: OGG_PAGE): Integer; cdecl;
ogg_page_eos_t = function(var og: OGG_PAGE): Integer; cdecl;
ogg_page_granulepos_t = function(var og: OGG_PAGE): OGG_INT64_T; cdecl;
ogg_page_serialno_t = function(var og: OGG_PAGE): Integer; cdecl;
ogg_page_pageno_t = function(var og: OGG_PAGE): LongInt; cdecl;
ogg_page_packets_t = function(var og: OGG_PAGE): Integer; cdecl;
ogg_packet_clear_t = procedure(var op: OGG_PACKET); cdecl;
var
ogg_stream_init : ogg_stream_init_t;
ogg_stream_clear : ogg_stream_clear_t;
ogg_stream_reset : ogg_stream_reset_t;
ogg_stream_destroy : ogg_stream_destroy_t;
ogg_stream_eos : ogg_stream_eos_t;
ogg_page_checksum_set : ogg_page_checksum_set_t;
ogg_page_version : ogg_page_version_t;
ogg_page_continued : ogg_page_continued_t;
ogg_page_bos : ogg_page_bos_t;
ogg_page_eos : ogg_page_eos_t;
ogg_page_granulepos : ogg_page_granulepos_t;
ogg_page_serialno : ogg_page_serialno_t;
ogg_page_pageno : ogg_page_pageno_t;
ogg_page_packets : ogg_page_packets_t;
ogg_packet_clear : ogg_packet_clear_t;
oggpack_writeinit : oggpack_writeinit_t;
oggpack_reset : oggpack_reset_t;
oggpack_writeclear : oggpack_writeclear_t;
oggpack_readinit : oggpack_readinit_t;
oggpack_write : oggpack_write_t;
oggpack_look : oggpack_look_t;
oggpack_look_huff : oggpack_look_huff_t;
oggpack_look1 : oggpack_look1_t;
oggpack_adv : oggpack_adv_t;
oggpack_adv_huff : oggpack_adv_huff_t;
oggpack_adv1 : oggpack_adv1_t;
oggpack_read : oggpack_read_t;
oggpack_read1 : oggpack_read1_t;
oggpack_bytes : oggpack_bytes_t;
oggpack_bits : oggpack_bits_t;
oggpack_get_buffer : oggpack_get_buffer_t;
ogg_stream_packetin : ogg_stream_packetin_t;
ogg_stream_pageout : ogg_stream_pageout_t;
ogg_stream_flush : ogg_stream_flush_t;
ogg_sync_init : ogg_sync_init_t;
ogg_sync_clear : ogg_sync_clear_t;
ogg_sync_reset : ogg_sync_reset_t;
ogg_sync_destroy : ogg_sync_destroy_t;
ogg_sync_buffer : ogg_sync_buffer_t;
ogg_sync_wrote : ogg_sync_wrote_t;
ogg_sync_pageseek : ogg_sync_pageseek_t;
ogg_sync_pageout : ogg_sync_pageout_t;
ogg_stream_pagein : ogg_stream_pagein_t;
ogg_stream_packetout : ogg_stream_packetout_t;
ogg_stream_packetpeek : ogg_stream_packetpeek_t;
implementation
{$IFDEF LINUX}
var
Libhandle : Pointer;
{$IFDEF SEARCH_LIBS}
Path : String;
{$ENDIF}
initialization
{$IFDEF SEARCH_LIBS}
Libhandle := nil;
Path := FindLibs(LiboggPath);
if Path <> '' then Libhandle := dlopen(@Path[1], RTLD_NOW or RTLD_GLOBAL);
{$ELSE}
Libhandle := dlopen(LiboggPath, RTLD_NOW or RTLD_GLOBAL);
{$ENDIF}
if Libhandle <> nil then
begin
LiboggLoaded := True;
ogg_stream_init := dlsym(Libhandle, 'ogg_stream_init');
ogg_stream_clear := dlsym(Libhandle, 'ogg_stream_clear');
ogg_stream_reset := dlsym(Libhandle, 'ogg_stream_reset');
ogg_stream_destroy := dlsym(Libhandle, 'ogg_stream_destroy');
ogg_stream_eos := dlsym(Libhandle, 'ogg_stream_eos');
ogg_page_checksum_set := dlsym(Libhandle, 'ogg_page_checksum_set');
ogg_page_version := dlsym(Libhandle, 'ogg_page_version');
ogg_page_continued := dlsym(Libhandle, 'ogg_page_continued');
ogg_page_bos := dlsym(Libhandle, 'ogg_page_bos');
ogg_page_eos := dlsym(Libhandle, 'ogg_page_eos');
ogg_page_granulepos := dlsym(Libhandle, 'ogg_page_granulepos');
ogg_page_serialno := dlsym(Libhandle, 'ogg_page_serialno');
ogg_page_pageno := dlsym(Libhandle, 'ogg_page_pageno');
ogg_page_packets := dlsym(Libhandle, 'ogg_page_packets');
ogg_packet_clear := dlsym(Libhandle, 'ogg_packet_clear');
oggpack_writeinit := dlsym(Libhandle, 'oggpack_writeinit');
oggpack_reset := dlsym(Libhandle, 'oggpack_reset');
oggpack_writeclear := dlsym(Libhandle, 'oggpack_writeclear');
oggpack_readinit := dlsym(Libhandle, 'oggpack_readinit');
oggpack_write := dlsym(Libhandle, 'oggpack_write');
oggpack_look := dlsym(Libhandle, 'oggpack_look');
oggpack_look_huff := dlsym(Libhandle, 'oggpack_look_huff');
oggpack_look1 := dlsym(Libhandle, 'oggpack_look1');
oggpack_adv := dlsym(Libhandle, 'oggpack_adv');
oggpack_adv_huff := dlsym(Libhandle, 'oggpack_adv_huff');
oggpack_adv1 := dlsym(Libhandle, 'oggpack_adv1');
oggpack_read := dlsym(Libhandle, 'oggpack_read');
oggpack_read1 := dlsym(Libhandle, 'oggpack_read1');
oggpack_bytes := dlsym(Libhandle, 'oggpack_bytes');
oggpack_bits := dlsym(Libhandle, 'oggpack_bits');
oggpack_get_buffer := dlsym(Libhandle, 'oggpack_get_buffer');
ogg_stream_packetin := dlsym(Libhandle, 'ogg_stream_packetin');
ogg_stream_pageout := dlsym(Libhandle, 'ogg_stream_pageout');
ogg_stream_flush := dlsym(Libhandle, 'ogg_stream_flush');
ogg_sync_init := dlsym(Libhandle, 'ogg_sync_init');
ogg_sync_clear := dlsym(Libhandle, 'ogg_sync_clear');
ogg_sync_reset := dlsym(Libhandle, 'ogg_sync_reset');
ogg_sync_destroy := dlsym(Libhandle, 'ogg_sync_destroy');
ogg_sync_buffer := dlsym(Libhandle, 'ogg_sync_buffer');
ogg_sync_wrote := dlsym(Libhandle, 'ogg_sync_wrote');
ogg_sync_pageseek := dlsym(Libhandle, 'ogg_sync_pageseek');
ogg_sync_pageout := dlsym(Libhandle, 'ogg_sync_pageout');
ogg_stream_pagein := dlsym(Libhandle, 'ogg_stream_pagein');
ogg_stream_packetout := dlsym(Libhandle, 'ogg_stream_packetout');
ogg_stream_packetpeek := dlsym(Libhandle, 'ogg_stream_packetpeek');
end;
finalization
if Libhandle <> nil then dlclose(Libhandle);
{$ENDIF}
{$IFDEF WIN32}
var
Libhandle : HMODULE;
initialization
Libhandle := LoadLibraryEx(LiboggPath, 0, 0);
if Libhandle <> 0 then
begin
LiboggLoaded := True;
ogg_stream_init := GetProcAddress(Libhandle, 'ogg_stream_init');
ogg_stream_clear := GetProcAddress(Libhandle, 'ogg_stream_clear');
ogg_stream_reset := GetProcAddress(Libhandle, 'ogg_stream_reset');
ogg_stream_destroy := GetProcAddress(Libhandle, 'ogg_stream_destroy');
ogg_stream_eos := GetProcAddress(Libhandle, 'ogg_stream_eos');
ogg_page_checksum_set := GetProcAddress(Libhandle, 'ogg_page_checksum_set');
ogg_page_version := GetProcAddress(Libhandle, 'ogg_page_version');
ogg_page_continued := GetProcAddress(Libhandle, 'ogg_page_continued');
ogg_page_bos := GetProcAddress(Libhandle, 'ogg_page_bos');
ogg_page_eos := GetProcAddress(Libhandle, 'ogg_page_eos');
ogg_page_granulepos := GetProcAddress(Libhandle, 'ogg_page_granulepos');
ogg_page_serialno := GetProcAddress(Libhandle, 'ogg_page_serialno');
ogg_page_pageno := GetProcAddress(Libhandle, 'ogg_page_pageno');
ogg_page_packets := GetProcAddress(Libhandle, 'ogg_page_packets');
ogg_packet_clear := GetProcAddress(Libhandle, 'ogg_packet_clear');
oggpack_writeinit := GetProcAddress(Libhandle, 'oggpack_writeinit');
oggpack_reset := GetProcAddress(Libhandle, 'oggpack_reset');
oggpack_writeclear := GetProcAddress(Libhandle, 'oggpack_writeclear');
oggpack_readinit := GetProcAddress(Libhandle, 'oggpack_readinit');
oggpack_write := GetProcAddress(Libhandle, 'oggpack_write');
oggpack_look := GetProcAddress(Libhandle, 'oggpack_look');
oggpack_look_huff := GetProcAddress(Libhandle, 'oggpack_look_huff');
oggpack_look1 := GetProcAddress(Libhandle, 'oggpack_look1');
oggpack_adv := GetProcAddress(Libhandle, 'oggpack_adv');
oggpack_adv_huff := GetProcAddress(Libhandle, 'oggpack_adv_huff');
oggpack_adv1 := GetProcAddress(Libhandle, 'oggpack_adv1');
oggpack_read := GetProcAddress(Libhandle, 'oggpack_read');
oggpack_read1 := GetProcAddress(Libhandle, 'oggpack_read1');
oggpack_bytes := GetProcAddress(Libhandle, 'oggpack_bytes');
oggpack_bits := GetProcAddress(Libhandle, 'oggpack_bits');
oggpack_get_buffer := GetProcAddress(Libhandle, 'oggpack_get_buffer');
ogg_stream_packetin := GetProcAddress(Libhandle, 'ogg_stream_packetin');
ogg_stream_pageout := GetProcAddress(Libhandle, 'ogg_stream_pageout');
ogg_stream_flush := GetProcAddress(Libhandle, 'ogg_stream_flush');
ogg_sync_init := GetProcAddress(Libhandle, 'ogg_sync_init');
ogg_sync_clear := GetProcAddress(Libhandle, 'ogg_sync_clear');
ogg_sync_reset := GetProcAddress(Libhandle, 'ogg_sync_reset');
ogg_sync_destroy := GetProcAddress(Libhandle, 'ogg_sync_destroy');
ogg_sync_buffer := GetProcAddress(Libhandle, 'ogg_sync_buffer');
ogg_sync_wrote := GetProcAddress(Libhandle, 'ogg_sync_wrote');
ogg_sync_pageseek := GetProcAddress(Libhandle, 'ogg_sync_pageseek');
ogg_sync_pageout := GetProcAddress(Libhandle, 'ogg_sync_pageout');
ogg_stream_pagein := GetProcAddress(Libhandle, 'ogg_stream_pagein');
ogg_stream_packetout := GetProcAddress(Libhandle, 'ogg_stream_packetout');
ogg_stream_packetpeek := GetProcAddress(Libhandle, 'ogg_stream_packetpeek');
end;
finalization
if Libhandle <> 0 then FreeLibrary(Libhandle);
{$ENDIF}
end.

480
acs/Src/fileformats/general/vorbiscodec.pas Normal file
View File

@@ -0,0 +1,480 @@
(*
delphi/kylix headers for oggvorbis software codec.
translated from codec.h header
by andrei borovsky, acs@compiler4.net
the original c/c++ headers and libraries (c) copyright 1994-2001
by the xiphophorus company http://www.xiph.org/
*)
{
$Log: vorbiscodec.pas,v $
Revision 1.1 2005/12/29 20:46:00 z0m3ie
fixed some problems with vorbis in lazarus
Revision 1.1 2005/12/19 18:36:56 z0m3ie
*** empty log message ***
Revision 1.1 2005/09/12 22:04:53 z0m3ie
modified structure again, fileformats are now in an sperat folder.
all File In/Out classes are capsulated from TFileIn and TFileOut
Revision 1.1 2005/08/25 20:18:00 z0m3ie
Version 2.4 restructure
TCDPlayer removed (fits not in component structure)
TMP3ToWavConverter removed (fits not in component structure)
Revision 1.2 2005/08/22 20:17:01 z0m3ie
changed Headers to log
changed mail adress
}
{$IFDEF FPC}
{$IFDEF WIN32}
{$PACKRECORDS C}
{$ENDIF WIN32}
{$ENDIF WIN32}
unit vorbiscodec;
{$ifdef fpc}
{$mode delphi}
{$endif}
interface
uses
ACS_Procs,
{$IFDEF LINUX}
baseunix,dl,
{$ENDIF}
{$IFDEF WIN32}
Windows,
{$ENDIF}
ogg;
type
PVORBIS_INFO = ^VORBIS_INFO;
VORBIS_INFO = record
version: Integer;
channels: Integer;
rate: LongInt;
(* The below bitrate declarations are *hints*.
Combinations of the three values carry the following implications:
all three set to the same value:
implies a fixed rate bitstream
only nominal set:
implies a VBR stream that averages the nominal bitrate. No hard
upper/lower limit
upper and or lower set:
implies a VBR bitstream that obeys the bitrate limits. nominal
may also be set to give a nominal rate.
none set:
the coder does not care to speculate. *)
bitrate_upper: LongInt;
bitrate_nominal: LongInt;
bitrate_lower: LongInt;
bitrate_window: LongInt;
codec_setup: Pointer;
end;
(* vorbis_dsp_state buffers the current vorbis audio
analysis/synthesis state. The DSP state belongs to a specific
logical bitstream *)
PVORBIS_DSP_STATE = ^VORBIS_DSP_STATE;
VORBIS_DSP_STATE = record
analysisp: Integer;
vi: PVORBIS_INFO;
pcm: PPFLOAT;
pcmret: PPFLOAT;
pcm_storage: Integer;
pcm_current: Integer;
pcm_returned: Integer;
preextrapolate: Integer;
eofflag: Integer;
lW: LongInt;
W: LongInt;
nW: LongInt;
centerW: LongInt;
granulepos: OGG_INT64_T;
sequence: OGG_INT64_T;
glue_bits: OGG_INT64_T;
time_bits: OGG_INT64_T;
floor_bits: OGG_INT64_T;
res_bits: OGG_INT64_T;
backend_state: Pointer;
end;
PALLOC_CHAIN = ^ALLOC_CHAIN;
ALLOC_CHAIN = record
ptr: Pointer;
next: PALLOC_CHAIN;
end;
VORBIS_BLOCK = record
// necessary stream state for linking to the framing abstraction
pcm: PPFLOAT;
// this is a pointer into local storage
opb: OGGPACK_BUFFER;
lW: LongInt;
W: LongInt;
nW: LongInt;
pcmend: Integer;
mode: Integer;
eofflag: Integer;
granulepos: OGG_INT64_T;
sequence: OGG_INT64_T;
vd: PVORBIS_DSP_STATE; // For read-only access of configuration
(* local storage to avoid remallocing; it's up to the mapping to
structure it *)
localstore: Pointer;
localtop: LongInt;
localalloc: LongInt;
totaluse: LongInt;
reap: PALLOC_CHAIN;
// bitmetrics for the frame
glue_bits: LongInt;
time_bits: LongInt;
floor_bits: LongInt;
res_bits: LongInt;
internal: Pointer;
end;
(* vorbis_block is a single block of data to be processed as part of
the analysis/synthesis stream; it belongs to a specific logical
bitstream, but is independant from other vorbis_blocks belonging to
that logical bitstream. *)
(* vorbis_info contains all the setup information specific to the
specific compression/decompression mode in progress (eg,
psychoacoustic settings, channel setup, options, codebook
etc). vorbis_info and substructures are in backends.h. *)
(* the comments are not part of vorbis_info so that vorbis_info can be
static storage *)
PVORBIS_COMMENT = ^VORBIS_COMMENT;
VORBIS_COMMENT = record
(* unlimited user comment fields. libvorbis writes 'libvorbis'
whatever vendor is set to in encode *)
user_comments: PPChar;
comment_lengths: PInteger;
comments: Integer;
vendor: PChar;
end;
(* libvorbis encodes in two abstraction layers; first we perform DSP
and produce a packet (see docs/analysis.txt). The packet is then
coded into a framed OggSquish bitstream by the second layer (see
docs/framing.txt). Decode is the reverse process; we sync/frame
the bitstream and extract individual packets, then decode the
packet back into PCM audio. *)
(* The extra framing/packetizing is used in streaming formats, such as
files. Over the net (such as with UDP), the framing and
packetization aren't necessary as they're provided by the transport
and the streaming layer is not used *)
// Vorbis PRIMITIVES: general
const
{$IFDEF LINUX}
LibvorbisPath = 'libvorbis.so*'; //'/usr/lib/libvorbis.so';
{$DEFINE SEARCH_LIBS}
{$ENDIF}
{$IFDEF WINDOWS}
LibvorbisPath = 'vorbis.dll';
{$ENDIF}
var
LibvorbisLoaded : Boolean = False;
type
vorbis_info_init_t = procedure(var vi: VORBIS_INFO); cdecl;
vorbis_info_clear_t = procedure(var vi: VORBIS_INFO); cdecl;
vorbis_info_blocksize_t = function(var vi: VORBIS_INFO;
zo: Integer): Integer; cdecl;
vorbis_comment_init_t = procedure(var vc: VORBIS_COMMENT); cdecl;
vorbis_comment_add_t = procedure(var vc: VORBIS_COMMENT;
comment: PChar); cdecl;
vorbis_comment_add_tag_t = procedure(var vc: VORBIS_COMMENT;
tag: PChar;
contents: PChar); cdecl;
vorbis_comment_query_t = function(var vc: VORBIS_COMMENT;
tag: PChar;
count: Integer): PChar; cdecl;
vorbis_comment_query_count_t = function(var vc: VORBIS_COMMENT;
tag: PChar): Integer; cdecl;
vorbis_comment_clear_t = procedure(var vc: VORBIS_COMMENT) cdecl;
vorbis_block_init_t = function(var v: VORBIS_DSP_STATE;
var vb: VORBIS_BLOCK): Integer; cdecl;
vorbis_block_clear_t = function(var vb: VORBIS_BLOCK): Integer; cdecl;
vorbis_dsp_clear_t = procedure(var v: VORBIS_DSP_STATE); cdecl;
// Vorbis PRIMITIVES: analysis/DSP layer
vorbis_analysis_init_t = function(var v: VORBIS_DSP_STATE;
var vi: VORBIS_INFO): Integer; cdecl;
vorbis_commentheader_out_t = function(var vc: VORBIS_COMMENT;
var op: OGG_PACKET): Integer; cdecl;
vorbis_analysis_headerout_t = function(var v: VORBIS_DSP_STATE;
var vc: VORBIS_COMMENT;
var op: OGG_PACKET;
var op_comm: OGG_PACKET;
var op_code: OGG_PACKET): Integer; cdecl;
vorbis_analysis_buffer_t = function(var v: VORBIS_DSP_STATE;
vals: Integer): PPFLOAT; cdecl;
vorbis_analysis_wrote_t = function(var v: VORBIS_DSP_STATE;
vals: Integer): Integer; cdecl;
vorbis_analysis_blockout_t = function(var v: VORBIS_DSP_STATE;
var vb: VORBIS_BLOCK): Integer; cdecl;
vorbis_analysis_t = function(var vb: VORBIS_BLOCK;
op: POGG_PACKET): Integer; cdecl;
vorbis_bitrate_addblock_t = function(var vb: VORBIS_BLOCK): Integer; cdecl;
vorbis_bitrate_flushpacket_t = function(var vd: VORBIS_DSP_STATE;
var op: OGG_PACKET): Integer; cdecl;
// Vorbis PRIMITIVES: synthesis layer
vorbis_synthesis_headerin_t = function(var vi: VORBIS_INFO;
var vc: VORBIS_COMMENT;
var op: OGG_PACKET): Integer; cdecl;
vorbis_synthesis_init_t = function(var v: VORBIS_DSP_STATE;
var vi: VORBIS_INFO): Integer; cdecl;
vorbis_synthesis_t = function(var vb: VORBIS_BLOCK;
var op: OGG_PACKET): Integer; cdecl;
vorbis_synthesis_blockin_t = function(var v: VORBIS_DSP_STATE;
var vb: VORBIS_BLOCK): Integer; cdecl;
vorbis_synthesis_pcmout_t = function(var v: VORBIS_DSP_STATE;
var pcm: PPFLOAT): Integer; cdecl;
vorbis_synthesis_read_t = function(var v: VORBIS_DSP_STATE;
samples: Integer): Integer; cdecl;
vorbis_packet_blocksize_t = function(var vi: VORBIS_INFO;
var op: OGG_PACKET): LongInt; cdecl;
var
vorbis_info_init : vorbis_info_init_t;
vorbis_info_clear : vorbis_info_clear_t;
vorbis_info_blocksize : vorbis_info_blocksize_t;
vorbis_comment_init : vorbis_comment_init_t;
vorbis_comment_add : vorbis_comment_add_t;
vorbis_comment_add_tag : vorbis_comment_add_tag_t;
vorbis_comment_query : vorbis_comment_query_t;
vorbis_comment_query_count : vorbis_comment_query_count_t;
vorbis_comment_clear : vorbis_comment_clear_t;
vorbis_block_init : vorbis_block_init_t;
vorbis_block_clear : vorbis_block_clear_t;
vorbis_dsp_clear : vorbis_dsp_clear_t;
vorbis_analysis_init : vorbis_analysis_init_t;
vorbis_commentheader_out : vorbis_commentheader_out_t;
vorbis_analysis_headerout : vorbis_analysis_headerout_t;
vorbis_analysis_buffer : vorbis_analysis_buffer_t;
vorbis_analysis_wrote : vorbis_analysis_wrote_t;
vorbis_analysis_blockout : vorbis_analysis_blockout_t;
vorbis_analysis : vorbis_analysis_t;
vorbis_bitrate_addblock : vorbis_bitrate_addblock_t;
vorbis_bitrate_flushpacket : vorbis_bitrate_flushpacket_t;
vorbis_synthesis_headerin : vorbis_synthesis_headerin_t;
vorbis_synthesis_init : vorbis_synthesis_init_t;
vorbis_synthesis : vorbis_synthesis_t;
vorbis_synthesis_blockin : vorbis_synthesis_blockin_t;
vorbis_synthesis_pcmout : vorbis_synthesis_pcmout_t;
vorbis_synthesis_read : vorbis_synthesis_read_t;
vorbis_packet_blocksize : vorbis_packet_blocksize_t;
// Vorbis ERRORS and return codes
const
OV_FALSE = -1;
OV_EOF = -2;
OV_HOLE = -3;
OV_EREAD = -128;
OV_EFAULT = -129;
OV_EIMPL = -130;
OV_EINVAL = -131;
OV_ENOTVORBIS = -132;
OV_EBADHEADER = -133;
OV_EVERSION = -134;
OV_ENOTAUDIO = -135;
OV_EBADPACKET = -136;
OV_EBADLINK = -137;
OV_ENOSEEK = -138;
implementation
{$IFDEF LINUX}
var
Libhandle : Pointer;
{$IFDEF SEARCH_LIBS}
Path : String;
{$ENDIF}
initialization
{$IFDEF SEARCH_LIBS}
Libhandle := nil;
Path := FindLibs(LibvorbisPath);
if Path <> '' then Libhandle := dlopen(@Path[1], RTLD_NOW or RTLD_GLOBAL);
{$ELSE}
Libhandle := dlopen(LibvorbisPath, RTLD_NOW or RTLD_GLOBAL);
{$ENDIF}
if Libhandle <> nil then
begin
LibvorbisLoaded := True;
vorbis_info_init := dlsym(Libhandle, 'vorbis_info_init');
vorbis_info_clear := dlsym(Libhandle, 'vorbis_info_clear');
vorbis_info_blocksize := dlsym(Libhandle, 'vorbis_info_blocksize');
vorbis_comment_init := dlsym(Libhandle, 'vorbis_comment_init');
vorbis_comment_add := dlsym(Libhandle, 'vorbis_comment_add');
vorbis_comment_add_tag := dlsym(Libhandle, 'vorbis_comment_add_tag');
vorbis_comment_query := dlsym(Libhandle, 'vorbis_comment_query');
vorbis_comment_query_count := dlsym(Libhandle, 'vorbis_comment_query_count');
vorbis_comment_clear := dlsym(Libhandle, 'vorbis_comment_clear');
vorbis_block_init := dlsym(Libhandle, 'vorbis_block_init');
vorbis_block_clear := dlsym(Libhandle, 'vorbis_block_clear');
vorbis_dsp_clear := dlsym(Libhandle, 'vorbis_dsp_clear');
vorbis_analysis_init := dlsym(Libhandle, 'vorbis_analysis_init');
vorbis_commentheader_out := dlsym(Libhandle, 'vorbis_commentheader_out');
vorbis_analysis_headerout := dlsym(Libhandle, 'vorbis_analysis_headerout');
vorbis_analysis_buffer := dlsym(Libhandle, 'vorbis_analysis_buffer');
vorbis_analysis_wrote := dlsym(Libhandle, 'vorbis_analysis_wrote');
vorbis_analysis_blockout := dlsym(Libhandle, 'vorbis_analysis_blockout');
vorbis_analysis := dlsym(Libhandle, 'vorbis_analysis');
vorbis_bitrate_addblock := dlsym(Libhandle, 'vorbis_bitrate_addblock');
vorbis_bitrate_flushpacket := dlsym(Libhandle, 'vorbis_bitrate_flushpacket');
vorbis_synthesis_headerin := dlsym(Libhandle, 'vorbis_synthesis_headerin');
vorbis_synthesis_init := dlsym(Libhandle, 'vorbis_synthesis_init');
vorbis_synthesis := dlsym(Libhandle, 'vorbis_synthesis');
vorbis_synthesis_blockin := dlsym(Libhandle, 'vorbis_synthesis_blockin');
vorbis_synthesis_pcmout := dlsym(Libhandle, 'vorbis_synthesis_pcmout');
vorbis_synthesis_read := dlsym(Libhandle, 'vorbis_synthesis_read');
vorbis_packet_blocksize := dlsym(Libhandle, 'vorbis_packet_blocksize');
end;
finalization
if libhandle <> nil then dlclose(libhandle);
{$ENDIF}
{$IFDEF WIN32}
var
Libhandle : HMODULE;
initialization
Libhandle := LoadLibraryEx(LibvorbisPath, 0, 0);
if Libhandle <> 0 then
begin
LibvorbisLoaded := True;
vorbis_info_init := GetProcAddress(Libhandle, 'vorbis_info_init');
vorbis_info_clear := GetProcAddress(Libhandle, 'vorbis_info_clear');
vorbis_info_blocksize := GetProcAddress(Libhandle, 'vorbis_info_blocksize');
vorbis_comment_init := GetProcAddress(Libhandle, 'vorbis_comment_init');
vorbis_comment_add := GetProcAddress(Libhandle, 'vorbis_comment_add');
vorbis_comment_add_tag := GetProcAddress(Libhandle, 'vorbis_comment_add_tag');
vorbis_comment_query := GetProcAddress(Libhandle, 'vorbis_comment_query');
vorbis_comment_query_count := GetProcAddress(Libhandle, 'vorbis_comment_query_count');
vorbis_comment_clear := GetProcAddress(Libhandle, 'vorbis_comment_clear');
vorbis_block_init := GetProcAddress(Libhandle, 'vorbis_block_init');
vorbis_block_clear := GetProcAddress(Libhandle, 'vorbis_block_clear');
vorbis_dsp_clear := GetProcAddress(Libhandle, 'vorbis_dsp_clear');
vorbis_analysis_init := GetProcAddress(Libhandle, 'vorbis_analysis_init');
vorbis_commentheader_out := GetProcAddress(Libhandle, 'vorbis_commentheader_out');
vorbis_analysis_headerout := GetProcAddress(Libhandle, 'vorbis_analysis_headerout');
vorbis_analysis_buffer := GetProcAddress(Libhandle, 'vorbis_analysis_buffer');
vorbis_analysis_wrote := GetProcAddress(Libhandle, 'vorbis_analysis_wrote');
vorbis_analysis_blockout := GetProcAddress(Libhandle, 'vorbis_analysis_blockout');
vorbis_analysis := GetProcAddress(Libhandle, 'vorbis_analysis');
vorbis_bitrate_addblock := GetProcAddress(Libhandle, 'vorbis_bitrate_addblock');
vorbis_bitrate_flushpacket := GetProcAddress(Libhandle, 'vorbis_bitrate_flushpacket');
vorbis_synthesis_headerin := GetProcAddress(Libhandle, 'vorbis_synthesis_headerin');
vorbis_synthesis_init := GetProcAddress(Libhandle, 'vorbis_synthesis_init');
vorbis_synthesis := GetProcAddress(Libhandle, 'vorbis_synthesis');
vorbis_synthesis_blockin := GetProcAddress(Libhandle, 'vorbis_synthesis_blockin');
vorbis_synthesis_pcmout := GetProcAddress(Libhandle, 'vorbis_synthesis_pcmout');
vorbis_synthesis_read := GetProcAddress(Libhandle, 'vorbis_synthesis_read');
vorbis_packet_blocksize := GetProcAddress(Libhandle, 'vorbis_packet_blocksize');
end;
finalization
if Libhandle <> 0 then FreeLibrary(Libhandle);
{$ENDIF}
end.

199
acs/Src/fileformats/general/vorbisenc.pas Normal file
View File

@@ -0,0 +1,199 @@
(*
delphi/kylix headers for oggvorbis software codec.
translated from vorbisenc.h header
by andrei borovsky, acs@compiler4.net
the original c/c++ headers and libraries (c) copyright 1994-2001
by the xiphophorus company http://www.xiph.org/
*)
{
$Log: vorbisenc.pas,v $
Revision 1.2 2005/12/29 20:46:00 z0m3ie
fixed some problems with vorbis in lazarus
Revision 1.1 2005/12/19 18:36:56 z0m3ie
*** empty log message ***
Revision 1.1 2005/09/12 22:04:53 z0m3ie
modified structure again, fileformats are now in an sperat folder.
all File In/Out classes are capsulated from TFileIn and TFileOut
Revision 1.1 2005/08/25 20:18:00 z0m3ie
Version 2.4 restructure
TCDPlayer removed (fits not in component structure)
TMP3ToWavConverter removed (fits not in component structure)
Revision 1.2 2005/08/22 20:17:01 z0m3ie
changed Headers to log
changed mail adress
}
unit vorbisenc;
{$ifdef fpc}
{$mode delphi}
{$endif}
interface
uses
ACS_Procs,
{$IFDEF LINUX}
baseunix,dl,
{$ENDIF}
{$IFDEF WIN32}
Windows,
{$ENDIF}
vorbiscodec;
const
{$IFDEF LINUX}
LibvorbisencPath = 'libvorbisenc.so*'; //'/usr/lib/libvorbisenc.so';
{$DEFINE SEARCH_LIBS}
{$ENDIF}
{$IFDEF WIN32}
LibvorbisencPath = 'vorbisenc.dll';
{$ENDIF}
OV_ECTL_RATEMANAGE2_GET = $14;
OV_ECTL_RATEMANAGE2_SET = $15;
var
LibvorbisencLoaded : Boolean = False;
type
vorbis_encode_init_t = function(var vi: VORBIS_INFO;
channels: LongInt;
rate: LongInt;
max_bitrate: LongInt;
nominal_bitrate: LongInt;
min_bitrate: LongInt): Integer cdecl;
vorbis_encode_setup_managed_t = function(var vi: VORBIS_INFO;
channels: LongInt;
rate: LongInt;
max_bitrate: LongInt;
nominal_bitrate: LongInt;
min_bitrate: LongInt): Integer; cdecl;
vorbis_encode_setup_vbr_t = function(var vi: VORBIS_INFO;
channels: LongInt;
rate: LongInt;
fl: Single): Integer; cdecl;
vorbis_encode_init_vbr_t = function(var vi: VORBIS_INFO;
channels: LongInt;
rate: LongInt;
base_quality: Single): Integer; cdecl;
vorbis_encode_setup_init_t = function(var vi: VORBIS_INFO): Integer; cdecl;
vorbis_encode_ctl_t = function(var vi: VORBIS_INFO;
number: Integer;
arg: Pointer): Integer; cdecl;
ovectl_ratemanage2_arg = record
management_active : Integer;
bitrate_limit_min_kbps : LongWord;
bitrate_limit_max_kbps : LongWord;
bitrate_limit_reservoir_bits : LongWord;
bitrate_limit_reservoir_bias : Double;
bitrate_average_kbps : LongWord;
bitrate_average_damping : Double;
end;
var
vorbis_encode_init : vorbis_encode_init_t;
vorbis_encode_setup_managed : vorbis_encode_setup_managed_t;
vorbis_encode_setup_vbr : vorbis_encode_setup_vbr_t;
vorbis_encode_init_vbr : vorbis_encode_init_vbr_t;
vorbis_encode_setup_init : vorbis_encode_setup_init_t;
vorbis_encode_ctl : vorbis_encode_ctl_t;
implementation
{$IFDEF LINUX}
var
Libhandle : Pointer;
{$IFDEF SEARCH_LIBS}
Path : String;
{$ENDIF}
initialization
{$IFDEF SEARCH_LIBS}
Libhandle := nil;
Path := FindLibs(LibvorbisencPath);
if Path <> '' then Libhandle := dlopen(@Path[1], RTLD_NOW or RTLD_GLOBAL);
{$ELSE}
Libhandle := dlopen(LibvorbisencPath, RTLD_NOW or RTLD_GLOBAL);
{$ENDIF}
if Libhandle <> nil then
begin
LibvorbisencLoaded := True;
vorbis_encode_init := dlsym(Libhandle, 'vorbis_encode_init');
vorbis_encode_setup_managed := dlsym(Libhandle, 'vorbis_encode_setup_managed');
vorbis_encode_setup_vbr := dlsym(Libhandle, 'vorbis_encode_setup_vbr');
vorbis_encode_init_vbr := dlsym(Libhandle, 'vorbis_encode_init_vbr');
vorbis_encode_setup_init := dlsym(Libhandle, 'vorbis_encode_setup_init');
vorbis_encode_ctl := dlsym(Libhandle, 'vorbis_encode_ctl');
end;
finalization
if libhandle <> nil then dlclose(Libhandle);
{$ENDIF}
{$IFDEF WIN32}
var
Libhandle : HMODULE;
initialization
Libhandle := LoadLibraryEx(LibvorbisencPath, 0, 0);
if Libhandle <> 0 then
begin
LibvorbisencLoaded := True;
vorbis_encode_init := GetProcAddress(Libhandle, 'vorbis_encode_init');
vorbis_encode_setup_managed := GetProcAddress(Libhandle, 'vorbis_encode_setup_managed');
vorbis_encode_setup_vbr := GetProcAddress(Libhandle, 'vorbis_encode_setup_vbr');
vorbis_encode_init_vbr := GetProcAddress(Libhandle, 'vorbis_encode_init_vbr');
vorbis_encode_setup_init := GetProcAddress(Libhandle, 'vorbis_encode_setup_init');
vorbis_encode_ctl := GetProcAddress(Libhandle, 'vorbis_encode_ctl');
end;
finalization
if libhandle <> 0 then FreeLibrary(Libhandle);
{$ENDIF}
end.

316
acs/Src/fileformats/general/vorbisfile.pas Normal file
View File

@@ -0,0 +1,316 @@
(*
delphi/kylix headers for oggvorbis software codec.
translated from vorbisfile.h header
by andrei borovsky, acs@compiler4.net
the original c/c++ headers and libraries (c) copyright 1994-2001
by the xiphophorus company http://www.xiph.org/
*)
{
$Log: vorbisfile.pas,v $
Revision 1.2 2005/12/29 20:46:00 z0m3ie
fixed some problems with vorbis in lazarus
Revision 1.1 2005/12/19 18:36:56 z0m3ie
*** empty log message ***
Revision 1.2 2005/10/09 19:01:03 z0m3ie
*** empty log message ***
Revision 1.1 2005/09/12 22:04:53 z0m3ie
modified structure again, fileformats are now in an sperat folder.
all File In/Out classes are capsulated from TFileIn and TFileOut
Revision 1.2 2005/09/10 08:25:40 z0m3ie
*** empty log message ***
Revision 1.1 2005/08/25 20:18:00 z0m3ie
Version 2.4 restructure
TCDPlayer removed (fits not in component structure)
TMP3ToWavConverter removed (fits not in component structure)
Revision 1.2 2005/08/22 20:17:01 z0m3ie
changed Headers to log
changed mail adress
}
{$IFDEF FPC}
{$IFDEF WIN32}
{$PACKRECORDS C}
{$ENDIF WIN32}
{$ENDIF WIN32}
unit vorbisfile;
{$ifdef fpc}
{$mode delphi}
{$endif}
interface
uses
ACS_Procs,
{$IFDEF LINUX}
baseunix,dl,
{$ENDIF}
{$IFDEF WIN32}
Windows,
{$ENDIF}
ogg,
vorbiscodec,
dynlibs;
(* The function prototypes for the callbacks are basically the same as for
the stdio functions fread, fseek, fclose, ftell.
The one difference is that the FILE* arguments have been replaced with
a void* - this is to be used as a pointer to whatever internal data these
functions might need. In the stdio case, it's just a FILE* cast to a void*
If you use other functions, check the docs for these functions and return
the right values. For seek_func(), you*MUST* return -1 if the stream is
unseekable *)
type
read_func_t = function(ptr : Pointer; size, nmemb : Cardinal;const datasource : Pointer) : Cardinal; cdecl;
seek_func_t = function(const datasource : Pointer; offset : ogg_int64_t; whence : Integer) : Integer; cdecl;
close_func_t = function(const datasource : Pointer) : Integer; cdecl;
tell_func_t = function(const datasource : Pointer) : Integer; cdecl;
OV_CALLBACKS = record
read_func : read_func_t;
seek_func : seek_func_t;
close_func : close_func_t;
tell_func : tell_func_t;
end;
const
NOTOPEN = 0;
PARTOPEN = 1;
OPENED = 2;
STREAMSET = 3;
INITSET = 4;
type
OGGVORBIS_FILE = record
datasource: Pointer; // Pointer to a FILE*, etc.
seekable: Integer;
offset: OGG_INT64_T;
_end: OGG_INT64_T;
oy: OGG_SYNC_STATE;
(* If the FILE handle isn't seekable (eg, a pipe),
only the current stream appears *)
links: Integer;
offsets: POGG_INT64_T;
dataoffsets: POGG_INT64_T;
serialnos: PLongInt;
pcmlengths: POGG_INT64_T;
vi: PVORBIS_INFO;
vc: PVORBIS_COMMENT;
// Decoding working state local storage
pcm_offset: OGG_INT64_T;
ready_state: Integer;
current_serialno: LongInt;
current_link: Integer;
bittrack: Double;
samptrack: Double;
os: OGG_STREAM_STATE;
(* take physical pages, weld into a logical
stream of packets *)
vd: VORBIS_DSP_STATE;
// central working state for the packet->PCM decoder
vb: VORBIS_BLOCK;
// local working space for packet->PCM decode
callbacks: OV_CALLBACKS;
end;
const
{$IFDEF LINUX}
LibvorbisfilePath = 'libvorbisfile.so*'; //'/usr/lib/libvorbisfile.so';
{$DEFINE SEARCH_LIBS}
{$ENDIF}
{$IFDEF WINDOWS}
LibvorbisfilePath = 'vorbisfile.dll';
{$ENDIF}
// stdio.h constants
SEEK_CUR = 1;
SEEK_END = 2;
SEEK_SET = 0;
var
LibvorbisfileLoaded : Boolean = False;
type
{$IFDEF LINUX}
ov_open_t = function(f: Pointer;var vf: OGGVORBIS_FILE;initial: PChar;ibytes: LongInt): Integer; cdecl;
ov_test_t = function(f: Pointer;var vf: OGGVORBIS_FILE;initial: PChar;ibytes: LongInt): Integer; cdecl;
{$ENDIF}
ov_clear_t = function(var vf: OGGVORBIS_FILE): Integer; cdecl;
ov_open_callbacks_t = function(datasource: Pointer;var vf: OGGVORBIS_FILE;initial: PChar;ibytes: LongInt; callbacks: OV_CALLBACKS): Integer; cdecl;
ov_test_callbacks_t = function(datasource: Pointer;var vf: OGGVORBIS_FILE;initial: PChar;ibytes: LongInt; callbacks: OV_CALLBACKS): Integer; cdecl;
ov_test_open_t = function(var vf: OGGVORBIS_FILE): Integer; cdecl;
ov_bitrate_t = function(var vf: OGGVORBIS_FILE;i: Integer): LongInt cdecl;
ov_bitrate_instant_t = function(var vf: OGGVORBIS_FILE): LongInt cdecl;
ov_streams_t = function(var vf: OGGVORBIS_FILE): LongInt cdecl;
ov_seekable_t = function(var vf: OGGVORBIS_FILE): LongInt cdecl;
ov_serialnumber_t = function(var vf: OGGVORBIS_FILE;i: Integer): LongInt cdecl;
ov_raw_total_t = function(var vf: OGGVORBIS_FILE;i: Integer): OGG_INT64_T cdecl;
ov_pcm_total_t = function(var vf: OGGVORBIS_FILE;i: Integer): OGG_INT64_T cdecl;
ov_time_total_t = function(var vf: OGGVORBIS_FILE;i: Integer): Double cdecl;
ov_raw_seek_t = function(var vf: OGGVORBIS_FILE;pos: LongInt): Integer cdecl;
ov_pcm_seek_t = function(var vf: OGGVORBIS_FILE;pos: OGG_INT64_T): Integer cdecl;
ov_pcm_seek_page_t = function(var vf: OGGVORBIS_FILE;pos: OGG_INT64_T): Integer cdecl;
ov_time_seek_t = function(var vf: OGGVORBIS_FILE;pos: Double): Integer cdecl;
ov_time_seek_page_t = function(var vf: OGGVORBIS_FILE;pos: Double): Integer cdecl;
ov_raw_tell_t = function(var vf: OGGVORBIS_FILE): OGG_INT64_T cdecl;
ov_pcm_tell_t = function(var vf: OGGVORBIS_FILE): OGG_INT64_T cdecl;
ov_time_tell_t = function(var vf: OGGVORBIS_FILE): Double cdecl;
ov_info_t = function(var vf: OGGVORBIS_FILE;link : Integer): PVORBIS_INFO cdecl;
ov_comment_t = function(var vf: OGGVORBIS_FILE;link : Integer): PVORBIS_COMMENT cdecl;
ov_read_float_t = function(var vf: OGGVORBIS_FILE;var pcm_channels: PPFLOAT;bitstream: PInteger): LongInt cdecl;
ov_read_t = function(var vf: OGGVORBIS_FILE;buffer: PChar;length: Integer;bigendianp: Integer;word: Integer;sgned: Integer;bitstream: PInteger): LongInt cdecl;
var
{$IFDEF LINUX}
ov_open : ov_open_t;
ov_test : ov_test_t;
{$ENDIF}
ov_clear : ov_clear_t;
ov_open_callbacks : ov_open_callbacks_t;
ov_test_callbacks : ov_test_callbacks_t;
ov_test_open : ov_test_open_t;
ov_bitrate : ov_bitrate_t;
ov_bitrate_instant : ov_bitrate_instant_t;
ov_streams : ov_streams_t;
ov_seekable : ov_seekable_t;
ov_serialnumber : ov_serialnumber_t;
ov_raw_total : ov_raw_total_t;
ov_pcm_total : ov_pcm_total_t;
ov_time_total : ov_time_total_t;
ov_raw_seek : ov_raw_seek_t;
ov_pcm_seek : ov_pcm_seek_t;
ov_pcm_seek_page : ov_pcm_seek_page_t;
ov_time_seek : ov_time_seek_t;
ov_time_seek_page : ov_time_seek_page_t;
ov_raw_tell : ov_raw_tell_t;
ov_pcm_tell : ov_pcm_tell_t;
ov_time_tell : ov_time_tell_t;
ov_info : ov_info_t;
ov_comment : ov_comment_t;
ov_read_float : ov_read_float_t;
ov_read : ov_read_t;
{$IFDEF WINDOWS}
Libhandle : HMODULE;
{$ELSE}
Libhandle : Pointer;
{$ENDIF}
procedure VORBISLoadLibrary;
implementation
{$IFDEF SEARCH_LIBS}
var
Path : String;
{$ENDIF}
procedure VORBISLoadLibrary;
begin
if LibvorbisfileLoaded then
exit;
{$IFDEF MSWINDOWS}
Libhandle := LoadLibrary(PChar(LibvorbisfilePath));
if Libhandle <> 0 then
begin
LibvorbisfileLoaded := True;
ov_clear := GetProcAddress(Libhandle, 'ov_clear');
ov_open_callbacks := GetProcAddress(Libhandle, 'ov_open_callbacks');
ov_test_callbacks := GetProcAddress(Libhandle, 'ov_test_callbacks');
ov_test_open := GetProcAddress(Libhandle, 'ov_test_open');
ov_bitrate := GetProcAddress(Libhandle, 'ov_bitrate');
ov_bitrate_instant := GetProcAddress(Libhandle, 'ov_bitrate_instant');
ov_streams := GetProcAddress(Libhandle, 'ov_streams');
ov_seekable := GetProcAddress(Libhandle, 'ov_seekable');
ov_serialnumber := GetProcAddress(Libhandle, 'ov_serialnumber');
ov_raw_total := GetProcAddress(Libhandle, 'ov_raw_total');
ov_pcm_total := GetProcAddress(Libhandle, 'ov_pcm_total');
ov_time_total := GetProcAddress(Libhandle, 'ov_time_total');
ov_raw_seek := GetProcAddress(Libhandle, 'ov_raw_seek');
ov_pcm_seek := GetProcAddress(Libhandle, 'ov_pcm_seek');
ov_pcm_seek_page := GetProcAddress(Libhandle, 'ov_pcm_seek_page');
ov_time_seek := GetProcAddress(Libhandle, 'ov_time_seek');
ov_time_seek_page := GetProcAddress(Libhandle, 'ov_time_seek_page');
ov_raw_tell := GetProcAddress(Libhandle, 'ov_raw_tell');
ov_pcm_tell := GetProcAddress(Libhandle, 'ov_pcm_tell');
ov_time_tell := GetProcAddress(Libhandle, 'ov_time_tell');
ov_info := GetProcAddress(Libhandle, 'ov_info');
ov_comment := GetProcAddress(Libhandle, 'ov_comment');
ov_read_float := GetProcAddress(Libhandle, 'ov_read_float');
ov_read := GetProcAddress(Libhandle, 'ov_read');
end;
{$ELSE}
{$IFDEF SEARCH_LIBS}
Libhandle := nil;
Path := FindLibs(LibvorbisfilePath);
if Path <> '' then Libhandle := dlopen(@Path[1], RTLD_NOW or RTLD_GLOBAL);
{$ELSE}
Libhandle := dlopen(LibvorbisfilePath, RTLD_NOW or RTLD_GLOBAL);
{$ENDIF}
if Libhandle <> nil then
begin {$IFDEF FPC}
{$IFDEF WIN32}
{$PACKRECORDS C}
{$ENDIF WIN32}
{$ENDIF WIN32}
LibvorbisfileLoaded := True;
ov_open := dlsym(Libhandle, 'ov_open');
ov_test := dlsym(Libhandle, 'ov_test');
ov_clear := dlsym(Libhandle, 'ov_clear');
ov_open_callbacks := dlsym(Libhandle, 'ov_open_callbacks');
ov_test_callbacks := dlsym(Libhandle, 'ov_test_callbacks');
ov_test_open := dlsym(Libhandle, 'ov_test_open');
ov_bitrate := dlsym(Libhandle, 'ov_bitrate');
ov_bitrate_instant := dlsym(Libhandle, 'ov_bitrate_instant');
ov_streams := dlsym(Libhandle, 'ov_streams');
ov_seekable := dlsym(Libhandle, 'ov_seekable');
ov_serialnumber := dlsym(Libhandle, 'ov_serialnumber');
ov_raw_total := dlsym(Libhandle, 'ov_raw_total');
ov_pcm_total := dlsym(Libhandle, 'ov_pcm_total');
ov_time_total := dlsym(Libhandle, 'ov_time_total');
ov_raw_seek := dlsym(Libhandle, 'ov_raw_seek');
ov_pcm_seek := dlsym(Libhandle, 'ov_pcm_seek');
ov_pcm_seek_page := dlsym(Libhandle, 'ov_pcm_seek_page');
ov_time_seek := dlsym(Libhandle, 'ov_time_seek');
ov_time_seek_page := dlsym(Libhandle, 'ov_time_seek_page');
ov_raw_tell := dlsym(Libhandle, 'ov_raw_tell');
ov_pcm_tell := dlsym(Libhandle, 'ov_pcm_tell');
ov_time_tell := dlsym(Libhandle, 'ov_time_tell');
ov_info := dlsym(Libhandle, 'ov_info');
ov_comment := dlsym(Libhandle, 'ov_comment');
ov_read_float := dlsym(Libhandle, 'ov_read_float');
ov_read := dlsym(Libhandle, 'ov_read');
end;
{$ENDIF}
end;
initialization
finalization
{$IFDEF MSWINDOWS}
if Libhandle <> 0 then FreeLibrary(Libhandle);
{$ELSE}
if libhandle <> nil then dlclose(Libhandle);
{$ENDIF}
end.