1059 lines
48 KiB
ObjectPascal
1059 lines
48 KiB
ObjectPascal
(*
|
|
delphi/kylix header for lame encoder.
|
|
translated from lame.h c/c++ header
|
|
by andrei borovsky, acs@compiler4.net
|
|
the original c/c++ header and library
|
|
copyright (c) 1999 mark taylor
|
|
|
|
Note by A.B.: Some fragments of the original header file are skipped.
|
|
See the comments below.
|
|
*)
|
|
|
|
{
|
|
$Log: lame.pas,v $
|
|
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 lame;
|
|
|
|
{$ifdef fpc}
|
|
{$mode delphi}
|
|
{$endif}
|
|
|
|
interface
|
|
|
|
uses
|
|
{$IFDEF WINDOWS}
|
|
Windows;
|
|
{$ENDIF}
|
|
|
|
{$IFDEF LINUX}
|
|
baseunix,dl;
|
|
{$ENDIF}
|
|
|
|
const
|
|
|
|
{$IFDEF LINUX}
|
|
LAME_PATH = '/usr/lib/libmp3lame.so';
|
|
{$ENDIF}
|
|
|
|
{$IFDEF WINDOWS}
|
|
LAME_PATH = 'lame_enc.dll';
|
|
{$ENDIF}
|
|
|
|
type
|
|
|
|
vbr_mode = (
|
|
vbr_off = 0,
|
|
vbr_mt, // obsolete, same as vbr_mtrh
|
|
vbr_rh,
|
|
vbr_abr,
|
|
vbr_mtrh,
|
|
vbr_max_indicator, // Don't use this! It's used for sanity checks.
|
|
vbr_default = vbr_rh // change this to change the default VBR mode of LAME
|
|
);
|
|
|
|
// MPEG modes
|
|
|
|
MPEG_mode = (
|
|
STEREO = 0,
|
|
JOINT_STEREO,
|
|
DUAL_CHANNEL, // LAME doesn't supports this!
|
|
MONO,
|
|
NOT_SET,
|
|
MAX_INDICATOR // Don't use this! It's used for sanity checks.
|
|
);
|
|
|
|
Padding_type = (
|
|
PAD_NO = 0,
|
|
PAD_ALL,
|
|
PAD_ADJUST,
|
|
PAD_MAX_INDICATOR // Don't use this! It's used for sanity checks.
|
|
);
|
|
|
|
preset_mode = (
|
|
(* values from 8 to 320 should be reserved for abr bitrates
|
|
for abr I'd suggest to directly use the targeted bitrate as a value *)
|
|
ABR_8 = 8,
|
|
ABR_320 = 320,
|
|
R3MIX = 1000,
|
|
STANDARD = 1001,
|
|
EXTREME = 1002,
|
|
INSANE = 1003,
|
|
STANDARD_FAST = 1004,
|
|
EXTREME_FAST = 1005
|
|
);
|
|
|
|
asm_optimizations = (
|
|
MMX = 1,
|
|
AMD_3DNOW = 2,
|
|
SSE = 3
|
|
);
|
|
|
|
(* Note by A.B.:
|
|
The following type is a placeholder for * lame_global_flags.
|
|
We treat this type as integer since it is interpreted as such by some
|
|
functions and the underlying structure is opaque anyway.
|
|
*)
|
|
|
|
PLame_global_flags = Integer;
|
|
|
|
PLame_t = Pointer;
|
|
|
|
// function pointers
|
|
|
|
(***********************************************************************
|
|
*
|
|
* The LAME API
|
|
* These functions should be called, in this order, for each
|
|
* MP3 file to be encoded
|
|
*
|
|
***********************************************************************)
|
|
|
|
(*
|
|
* REQUIRED:
|
|
* initialize the encoder. sets default for all encoder paramters,
|
|
* returns -1 if some malloc()'s failed
|
|
* otherwise returns 0
|
|
*)
|
|
|
|
lame_init_t = function : PLame_global_flags; cdecl;
|
|
|
|
(*
|
|
* OPTIONAL:
|
|
* set as needed to override defaults
|
|
*)
|
|
|
|
(********************************************************************
|
|
* input stream description
|
|
***********************************************************************)
|
|
// number of samples. default = 2^32-1
|
|
|
|
lame_set_num_samples_t = function(handle : PLame_global_flags; ul : LongWord)
|
|
: Integer; cdecl;
|
|
lame_get_num_samples_t = function(handle : PLame_global_flags) : LongWord; cdecl;
|
|
|
|
// input sample rate in Hz. default = 44100hz
|
|
lame_set_in_samplerate_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_in_samplerate_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// number of channels in input stream. default=2
|
|
lame_set_num_channels_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_num_channels_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* scale the input by this amount before encoding. default=0 (disabled)
|
|
(not used by decoding routines) *)
|
|
lame_set_scale_t = function(handle : PLame_global_flags; d : Single)
|
|
: Integer; cdecl;
|
|
lame_get_scale_t = function(handle : PLame_global_flags) : Single; cdecl;
|
|
|
|
(* scale the channel 0 (left) input by this amount before encoding.
|
|
default=0 (disabled)
|
|
(not used by decoding routines) *)
|
|
lame_set_scale_left_t = function(handle : PLame_global_flags; d : Single)
|
|
: Integer; cdecl;
|
|
lame_get_scale_left_t = function(handle : PLame_global_flags) : Single; cdecl;
|
|
|
|
(* scale the channel 1 (right) input by this amount before encoding.
|
|
default=0 (disabled)
|
|
(not used by decoding routines) *)
|
|
|
|
lame_set_scale_right_t = function(handle : PLame_global_flags; d : Single)
|
|
: Integer; cdecl;
|
|
lame_get_scale_right_t = function(handle : PLame_global_flags) : Single; cdecl;
|
|
|
|
(* output sample rate in Hz. default = 0, which means LAME picks best value
|
|
based on the amount of compression. MPEG only allows:
|
|
MPEG1 32, 44.1, 48khz
|
|
MPEG2 16, 22.05, 24
|
|
MPEG2.5 8, 11.025, 12
|
|
(not used by decoding routines) *)
|
|
|
|
lame_set_out_samplerate_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_out_samplerate_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(********************************************************************
|
|
* general control parameters
|
|
***********************************************************************)
|
|
// 1=cause LAME to collect data for an MP3 frame analyzer. default=0
|
|
lame_set_analysis_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_analysis_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* 1 = write a Xing VBR header frame.
|
|
default = 1 for VBR/ABR modes, 0 for CBR mode
|
|
this variable must have been added by a Hungarian notation Windows programmer :-) *)
|
|
lame_set_bWriteVbrTag_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_bWriteVbrTag_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// 1=decode only. use lame/mpglib to convert mp3/ogg to wav. default=0
|
|
lame_set_decode_only_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_decode_only_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// 1=encode a Vorbis .ogg file. default=0
|
|
lame_set_ogg_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_ogg_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* internal algorithm selection. True quality is determined by the bitrate
|
|
but this variable will effect quality by selecting expensive or cheap algorithms.
|
|
quality=0..9. 0=best (very slow). 9=worst.
|
|
recommended: 2 near-best quality, not too slow
|
|
5 good quality, fast
|
|
7 ok quality, really fast *)
|
|
lame_set_quality_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_quality_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* mode = 0,1,2,3 = stereo, jstereo, dual channel (not supported), mono
|
|
default: lame picks based on compression ration and input channels *)
|
|
lame_set_mode_t = function(handle : PLame_global_flags; MPEGMode : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_mode_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* mode_automs. Use a M/S mode with a switching threshold based on
|
|
compression ratio
|
|
default = 0 (disabled) *)
|
|
lame_set_mode_automs_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_mode_automs_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* force_ms. Force M/S for all frames. For testing only.
|
|
default = 0 (disabled) *)
|
|
lame_set_force_ms_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_force_ms_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// use free_format? default = 0 (disabled)
|
|
lame_set_free_format_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_free_format_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// Note by A.B.: Attention! Skipping optional debug/error messages functions.
|
|
|
|
// set one of brate compression ratio. default is compression ratio of 11.
|
|
lame_set_brate_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_brate_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
lame_set_compression_ratio_t = function(handle : PLame_global_flags; d : Single)
|
|
: Integer; cdecl;
|
|
lame_get_compression_ratio_t = function(handle : PLame_global_flags) : Single; cdecl;
|
|
|
|
lame_set_preset_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_set_asm_optimizations_t = function(handle : PLame_global_flags; i1, i2 : Integer)
|
|
: Integer; cdecl;
|
|
|
|
(********************************************************************
|
|
* frame params
|
|
***********************************************************************)
|
|
// mark as copyright. default=0
|
|
lame_set_copyright_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_copyright_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// mark as original. default=1
|
|
lame_set_original_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_original_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// error_protection. Use 2 bytes from each frame for CRC checksum. default=0
|
|
lame_set_error_protection_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_error_protection_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// padding_type. 0=pad no frames 1=pad all frames 2=adjust padding(default)
|
|
lame_set_padding_type_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_padding_type_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// MP3 'private extension' bit Meaningless. default=0
|
|
lame_set_extension_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_extension_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// enforce strict ISO compliance. default=0
|
|
lame_set_strict_ISO_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_strict_ISO_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(********************************************************************
|
|
* VBR control
|
|
***********************************************************************)
|
|
|
|
// Types of VBR. default = vbr_off = CBR
|
|
lame_set_VBR_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_VBR_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// VBR quality level. 0=highest 9=lowest
|
|
lame_set_VBR_q_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_VBR_q_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// Ignored except for VBR=vbr_abr (ABR mode)
|
|
lame_set_VBR_mean_bitrate_kbps_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_VBR_mean_bitrate_kbps_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
lame_set_VBR_min_bitrate_kbps_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_VBR_min_bitrate_kbps_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
lame_set_VBR_max_bitrate_kbps_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_VBR_max_bitrate_kbps_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* 1=stricetly enforce VBR_min_bitrate. Normally it will be violated for
|
|
analog silence *)
|
|
lame_set_VBR_hard_min_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_VBR_hard_min_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(********************************************************************
|
|
* Filtering control
|
|
***********************************************************************)
|
|
// freq in Hz to apply lowpass. Default = 0 = lame chooses. -1 = disabled
|
|
lame_set_lowpassfreq_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_lowpassfreq_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
// width of transition band, in Hz. Default = one polyphase filter band
|
|
lame_set_lowpasswidth_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_lowpasswidth_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// freq in Hz to apply highpass. Default = 0 = lame chooses. -1 = disabled
|
|
lame_set_highpassfreq_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_highpassfreq_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
// width of transition band, in Hz. Default = one polyphase filter band
|
|
lame_set_highpasswidth_t = function(handle : PLame_global_flags; i : Integer)
|
|
: Integer; cdecl;
|
|
lame_get_highpasswidth_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// Note by A.B.: Attention! Skipping psycho acoustics and other special functions
|
|
|
|
(************************************************************************
|
|
* internal variables, cannot be set... *
|
|
* provided because they may be of use to calling application *
|
|
************************************************************************)
|
|
// version 0=MPEG-2 1=MPEG-1 (2=MPEG-2.5)
|
|
lame_get_version_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// encoder delay
|
|
lame_get_encoder_delay_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* padding appended to the input to make sure decoder can fully decode
|
|
all input. Note that this value can only be calculated during the
|
|
call to lame_encoder_flush(). Before lame_encoder_flush() has
|
|
been called, the value of encoder_padding = 0. *)
|
|
lame_get_encoder_padding_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// size of MPEG frame
|
|
lame_get_framesize_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// number of PCM samples buffered, but not yet encoded to mp3 data.
|
|
lame_get_mf_samples_to_encode_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* size (bytes) of mp3 data buffered, but not yet encoded.
|
|
this is the number of bytes which would be output by a call to
|
|
lame_encode_flush_nogap. NOTE: lame_encode_flush() will return
|
|
more bytes than this because it will encode the reamining buffered
|
|
PCM samples before flushing the mp3 buffers. *)
|
|
lame_get_size_mp3buffer_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// number of frames encoded so far
|
|
lame_get_frameNum_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(* lame's estimate of the total number of frames to be encoded
|
|
only valid if calling program set num_samples *)
|
|
lame_get_totalframes_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(*
|
|
* REQUIRED:
|
|
* sets more internal configuration based on data provided above.
|
|
* returns -1 if something failed.
|
|
*)
|
|
|
|
lame_init_params_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(*
|
|
* OPTIONAL:
|
|
* get the version number, in a string. of the form:
|
|
* "3.63 (beta)" or just "3.63".
|
|
*)
|
|
get_lame_version_t = function : PChar; cdecl;
|
|
get_lame_short_version_t = function : PChar; cdecl;
|
|
get_lame_very_short_version_t = function : PChar; cdecl;
|
|
get_psy_version_t = function : PChar; cdecl;
|
|
get_lame_url_t = function : PChar; cdecl;
|
|
|
|
(*
|
|
* OPTIONAL:
|
|
* get the version numbers in numerical form.
|
|
*)
|
|
|
|
lame_version_t = record
|
|
// generic LAME version
|
|
major : Integer;
|
|
minor : Integer;
|
|
alpha : Integer; // 0 if not an alpha version
|
|
beta : Integer; // 0 if not a beta version
|
|
|
|
// version of the psy model
|
|
psy_major : Integer;
|
|
psy_minor : Integer;
|
|
psy_alpha : Integer; // 0 if not an alpha version
|
|
psy_beta : Integer; // 0 if not a beta version
|
|
|
|
// compile time features
|
|
features : PChar; // Don't make assumptions about the contents!
|
|
end;
|
|
|
|
get_lame_version_numerical_t = procedure(lnv : lame_version_t); cdecl;
|
|
|
|
// Note by A.B.: Attention! Skipping optional functions printing internal lame configuration
|
|
|
|
(*
|
|
* input pcm data, output (maybe) mp3 frames.
|
|
* This routine handles all buffering, resampling and filtering for you.
|
|
*
|
|
* return code number of bytes output in mp3buf. Can be 0
|
|
* -1: mp3buf was too small
|
|
* -2: malloc() problem
|
|
* -3: lame_init_params() not called
|
|
* -4: psycho acoustic problems
|
|
* -5: ogg cleanup encoding error
|
|
* -6: ogg frame encoding error
|
|
*
|
|
* The required mp3buf_size can be computed from num_samples,
|
|
* samplerate and encoding rate, but here is a worst case estimate:
|
|
*
|
|
* mp3buf_size in bytes = 1.25*num_samples + 7200
|
|
*
|
|
* I think a tighter bound could be: (mt, March 2000)
|
|
* MPEG1:
|
|
* num_samples*(bitrate/8)/samplerate + 4*1152*(bitrate/8)/samplerate + 512
|
|
* MPEG2:
|
|
* num_samples*(bitrate/8)/samplerate + 4*576*(bitrate/8)/samplerate + 256
|
|
*
|
|
* but test first if you use that!
|
|
*
|
|
* set mp3buf_size = 0 and LAME will not check if mp3buf_size is
|
|
* large enough.
|
|
*
|
|
* NOTE:
|
|
* if gfp->num_channels=2, but gfp->mode = 3 (mono), the L & R channels
|
|
* will be averaged into the L channel before encoding only the L channel
|
|
* This will overwrite the data in buffer_l[] and buffer_r[].
|
|
*
|
|
*)
|
|
|
|
lame_encode_buffer_t = function(handle : PLame_global_flags; // global context handle
|
|
buffer_l : PShortInt; // PCM data for left channel
|
|
buffer_r : PShortInt; // PCM data for right channel
|
|
nsamples : Integer; // number of samples per channel
|
|
mp3buf : PByte; // pointer to encoded MP3 stream
|
|
mp3buf_size : Integer // number of valid octets in this stream
|
|
) : Integer; cdecl;
|
|
|
|
(*
|
|
* as above, but input has L & R channel data interleaved.
|
|
* NOTE:
|
|
* num_samples = number of samples in the L (or R)
|
|
* channel, not the total number of samples in pcm[]
|
|
*)
|
|
lame_encode_buffer_interleaved_t = function(handle : PLame_global_flags; // global context handle
|
|
pcm : PShortInt; (* PCM data for left and right
|
|
channel, interleaved *)
|
|
num_samples : Integer; (* number of samples per channel,
|
|
_not_ number of samples in pcm[] *)
|
|
mp3buf : PByte; // pointer to encoded MP3 stream
|
|
mp3buf_size : Integer // number of valid octets in this stream
|
|
) : Integer; cdecl;
|
|
|
|
(* as lame_encode_buffer, but for 'float's.
|
|
* !! NOTE: !! data must still be scaled to be in the same range as
|
|
* short int, +/- 32768
|
|
*)
|
|
lame_encode_buffer_float_t = function(handle : PLame_global_flags; // global context handle
|
|
buffer_l : PSingle; // PCM data for left channel
|
|
buffer_r : PSingle; // PCM data for right channel
|
|
nsamples : Integer; // number of samples per channel
|
|
mp3buf : PByte; // pointer to encoded MP3 stream
|
|
mp3buf_size : Integer // number of valid octets in this stream
|
|
) : Integer; cdecl;
|
|
|
|
// Note by A.B.: Attention! Skipping several variants of encoding functions
|
|
|
|
(*
|
|
* REQUIRED:
|
|
* lame_encode_flush will flush the intenal PCM buffers, padding with
|
|
* 0's to make sure the final frame is complete, and then flush
|
|
* the internal MP3 buffers, and thus may return a
|
|
* final few mp3 frames. 'mp3buf' should be at least 7200 bytes long
|
|
* to hold all possible emitted data.
|
|
*
|
|
* will also write id3v1 tags (if any) into the bitstream
|
|
*
|
|
* return code = number of bytes output to mp3buf. Can be 0
|
|
*)
|
|
lame_encode_flush_t = function(handle : PLame_global_flags; // global context handle
|
|
mp3buf : PByte; // pointer to encoded MP3 stream
|
|
size : Integer // number of valid octets in this stream
|
|
) : Integer; cdecl;
|
|
|
|
(*
|
|
* OPTIONAL:
|
|
* lame_encode_flush_nogap will flush the internal mp3 buffers and pad
|
|
* the last frame with ancillary data so it is a complete mp3 frame.
|
|
*
|
|
* 'mp3buf' should be at least 7200 bytes long
|
|
* to hold all possible emitted data.
|
|
*
|
|
* After a call to this routine, the outputed mp3 data is complete, but
|
|
* you may continue to encode new PCM samples and write future mp3 data
|
|
* to a different file. The two mp3 files will play back with no gaps
|
|
* if they are concatenated together.
|
|
*
|
|
* This routine will NOT write id3v1 tags into the bitstream.
|
|
*
|
|
* return code = number of bytes output to mp3buf. Can be 0
|
|
*)
|
|
lame_encode_flush_nogap_t = function(handle : PLame_global_flags; // global context handle
|
|
mp3buf : PByte; // pointer to encoded MP3 stream
|
|
size : Integer // number of valid octets in this stream
|
|
) : Integer; cdecl;
|
|
|
|
(*
|
|
* OPTIONAL:
|
|
* Normally, this is called by lame_init_params(). It writes id3v2 and
|
|
* Xing headers into the front of the bitstream, and sets frame counters
|
|
* and bitrate histogram data to 0. You can also call this after
|
|
* lame_encode_flush_nogap().
|
|
*)
|
|
lame_init_bitstream_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
// Note by A.B.: Attention! Skipping several optional functions.
|
|
|
|
(*
|
|
* REQUIRED:
|
|
* final call to free all remaining buffers
|
|
*)
|
|
lame_close_t = function(handle : PLame_global_flags) : Integer; cdecl;
|
|
|
|
(*********************************************************************
|
|
*
|
|
* decoding
|
|
*
|
|
* a simple interface to mpglib, part of mpg123, is also included if
|
|
* libmp3lame is compiled with HAVE_MPGLIB
|
|
*
|
|
*********************************************************************)
|
|
|
|
PMP3data_struct = ^mp3data_struct;
|
|
|
|
mp3data_struct = record
|
|
header_parsed : Integer; (* 1 if header was parsed and following
|
|
data was computed *)
|
|
stereo : Integer; // number of channels
|
|
samplerate : Integer; // sample rate
|
|
bitrate : Integer; // bitrate
|
|
mode : Integer; // mp3 frame type
|
|
mode_ext : Integer; // mp3 frame type
|
|
framesize : Integer; // number of samples per mp3 frame
|
|
|
|
// this data is only computed if mpglib detects a Xing VBR header
|
|
nsamp : LongWord; // number of samples in mp3 file.
|
|
totalframes : Integer; // total number of frames in mp3 file
|
|
|
|
// this data is not currently computed by the mpglib routines
|
|
framenum : Integer; // frames decoded counter */
|
|
end;
|
|
|
|
|
|
// required call to initialize decoder
|
|
lame_decode_init_t = function : Integer; cdecl;
|
|
|
|
(*********************************************************************
|
|
* input 1 mp3 frame, output (maybe) pcm data.
|
|
* lame_decode() return code:
|
|
* -1: error
|
|
* 0: need more data
|
|
* n>0: size of pcm output
|
|
*********************************************************************)
|
|
lame_decode_t = function(mp3buf : PByte; len : Integer; pcm_l, pcm_r : PShortInt)
|
|
: Integer; cdecl;
|
|
|
|
// same as lame_decode, and also returns mp3 header data
|
|
lame_decode_headers_t = function(mp3buf : PByte; len : Integer; pcm_l, pcm_r : PShortInt;
|
|
mp3data : PMP3data_struct) : Integer; cdecl;
|
|
|
|
// same as lame_decode, but returns at most one frame
|
|
lame_decode1_t = function(mp3buf : PByte; len : Integer; pcm_l, pcm_r : PShortInt)
|
|
: Integer; cdecl;
|
|
|
|
// same as lame_decode1, but returns at most one frame and mp3 header data
|
|
lame_decode1_headers_t = function(mp3buf : PByte; len : Integer; pcm_l, pcm_r : PShortInt;
|
|
mp3data : PMP3data_struct) : Integer; cdecl;
|
|
|
|
(*********************************************************************
|
|
*
|
|
* id3tag stuff
|
|
*
|
|
*********************************************************************)
|
|
|
|
(*
|
|
* The original header file is
|
|
* id3tag.h -- Interface to write ID3 version 1 and 2 tags.
|
|
* Copyright (C) 2000 Don Melton.
|
|
*)
|
|
|
|
id3tag_genre_list_cbf = procedure(Number : Integer; Genre : PChar; CustomData : Pointer); cdecl;
|
|
|
|
// utility to obtain alphabetically sorted list of genre names with numbers */
|
|
id3tag_genre_list_t = procedure(handler : id3tag_genre_list_cbf; CustomData : Pointer); cdecl;
|
|
|
|
id3tag_init_t = procedure(handle : PLame_global_flags); cdecl;
|
|
|
|
// force addition of version 2 tag */
|
|
id3tag_add_v2_t = procedure(handle : PLame_global_flags); cdecl;
|
|
|
|
// add only a version 1 tag
|
|
id3tag_v1_only_t = procedure(handle : PLame_global_flags); cdecl;
|
|
|
|
// add only a version 2 tag
|
|
id3tag_v2_only_t = procedure(handle : PLame_global_flags); cdecl;
|
|
|
|
// pad version 1 tag with spaces instead of nulls
|
|
id3tag_space_v1_t = procedure(handle : PLame_global_flags); cdecl;
|
|
|
|
// pad version 2 tag with extra 128 bytes
|
|
id3tag_pad_v2_t = procedure(handle : PLame_global_flags); cdecl;
|
|
|
|
id3tag_set_title_t = procedure(handle : PLame_global_flags; title : PChar); cdecl;
|
|
id3tag_set_artist_t = procedure(handle : PLame_global_flags; artist : PChar); cdecl;
|
|
id3tag_set_album_t = procedure(handle : PLame_global_flags; album : PChar); cdecl;
|
|
id3tag_set_year_t = procedure(handle : PLame_global_flags; year : PChar); cdecl;
|
|
id3tag_set_comment_t = procedure(handle : PLame_global_flags; comment : PChar); cdecl;
|
|
id3tag_set_track_t = procedure(handle : PLame_global_flags; track : PChar); cdecl;
|
|
|
|
// return non-zero result if genre name or number is invalid
|
|
id3tag_set_genre_t = function(handle : PLame_global_flags; genre : PChar) : Integer; cdecl;
|
|
|
|
const
|
|
LAME_MAXMP3BUFFER = 16384;
|
|
|
|
var
|
|
LameLoaded : Boolean = False;
|
|
|
|
lame_init : lame_init_t;
|
|
lame_set_num_samples : lame_set_num_samples_t;
|
|
lame_get_num_samples : lame_get_num_samples_t;
|
|
lame_set_in_samplerate : lame_set_in_samplerate_t;
|
|
lame_get_in_samplerate : lame_get_in_samplerate_t;
|
|
lame_set_num_channels : lame_set_num_channels_t;
|
|
lame_get_num_channels : lame_get_num_channels_t;
|
|
lame_set_scale : lame_set_scale_t;
|
|
lame_get_scale : lame_get_scale_t;
|
|
lame_set_scale_left : lame_set_scale_left_t;
|
|
lame_get_scale_left : lame_get_scale_left_t;
|
|
lame_set_scale_right : lame_set_scale_right_t;
|
|
lame_get_scale_right : lame_get_scale_right_t;
|
|
lame_set_out_samplerate : lame_set_out_samplerate_t;
|
|
lame_get_out_samplerate : lame_get_out_samplerate_t;
|
|
lame_set_analysis : lame_set_analysis_t;
|
|
lame_get_analysis : lame_get_analysis_t;
|
|
lame_set_bWriteVbrTag : lame_set_bWriteVbrTag_t;
|
|
lame_get_bWriteVbrTag : lame_get_bWriteVbrTag_t;
|
|
lame_set_decode_only : lame_set_decode_only_t;
|
|
lame_get_decode_only : lame_get_decode_only_t;
|
|
lame_set_ogg : lame_set_ogg_t;
|
|
lame_get_ogg : lame_get_ogg_t;
|
|
lame_set_quality : lame_set_quality_t;
|
|
lame_get_quality : lame_get_quality_t;
|
|
lame_set_mode : lame_set_mode_t;
|
|
lame_get_mode : lame_get_mode_t;
|
|
lame_set_mode_automs : lame_set_mode_automs_t;
|
|
lame_get_mode_automs : lame_get_mode_automs_t;
|
|
lame_set_force_ms : lame_set_force_ms_t;
|
|
lame_get_force_ms : lame_get_force_ms_t;
|
|
lame_set_free_format : lame_set_free_format_t;
|
|
lame_get_free_format : lame_get_free_format_t;
|
|
lame_set_brate : lame_set_brate_t;
|
|
lame_get_brate : lame_get_brate_t;
|
|
lame_set_compression_ratio : lame_set_compression_ratio_t;
|
|
lame_get_compression_ratio : lame_get_compression_ratio_t;
|
|
lame_set_preset : lame_set_preset_t;
|
|
lame_set_asm_optimizations : lame_set_asm_optimizations_t;
|
|
lame_set_copyright : lame_set_copyright_t;
|
|
lame_get_copyright : lame_get_copyright_t;
|
|
lame_set_original : lame_set_original_t;
|
|
lame_get_original : lame_get_original_t;
|
|
lame_set_error_protection : lame_set_error_protection_t;
|
|
lame_get_error_protection : lame_get_error_protection_t;
|
|
lame_set_padding_type : lame_set_padding_type_t;
|
|
lame_get_padding_type : lame_get_padding_type_t;
|
|
lame_set_extension : lame_set_extension_t;
|
|
lame_get_extension : lame_get_extension_t;
|
|
lame_set_strict_ISO : lame_set_strict_ISO_t;
|
|
lame_get_strict_ISO : lame_get_strict_ISO_t;
|
|
lame_set_VBR : lame_set_VBR_t;
|
|
lame_get_VBR : lame_get_VBR_t;
|
|
lame_set_VBR_q : lame_set_VBR_q_t;
|
|
lame_get_VBR_q : lame_get_VBR_q_t;
|
|
lame_set_VBR_mean_bitrate_kbps : lame_set_VBR_mean_bitrate_kbps_t;
|
|
lame_get_VBR_mean_bitrate_kbps : lame_get_VBR_mean_bitrate_kbps_t;
|
|
lame_set_VBR_min_bitrate_kbps : lame_set_VBR_min_bitrate_kbps_t;
|
|
lame_get_VBR_min_bitrate_kbps : lame_get_VBR_min_bitrate_kbps_t;
|
|
lame_set_VBR_max_bitrate_kbps : lame_set_VBR_max_bitrate_kbps_t;
|
|
lame_get_VBR_max_bitrate_kbps : lame_get_VBR_max_bitrate_kbps_t;
|
|
lame_set_VBR_hard_min : lame_set_VBR_hard_min_t;
|
|
lame_get_VBR_hard_min : lame_get_VBR_hard_min_t;
|
|
lame_set_lowpassfreq : lame_set_lowpassfreq_t;
|
|
lame_get_lowpassfreq : lame_get_lowpassfreq_t;
|
|
lame_set_lowpasswidth : lame_set_lowpasswidth_t;
|
|
lame_get_lowpasswidth : lame_get_lowpasswidth_t;
|
|
lame_set_highpassfreq : lame_set_highpassfreq_t;
|
|
lame_get_highpassfreq : lame_get_highpassfreq_t;
|
|
lame_set_highpasswidth : lame_set_highpasswidth_t;
|
|
lame_get_highpasswidth : lame_get_highpasswidth_t;
|
|
lame_get_version : lame_get_version_t;
|
|
lame_get_encoder_delay : lame_get_encoder_delay_t;
|
|
lame_get_encoder_padding : lame_get_encoder_padding_t;
|
|
lame_get_framesize : lame_get_framesize_t;
|
|
lame_get_mf_samples_to_encode : lame_get_mf_samples_to_encode_t;
|
|
lame_get_size_mp3buffer : lame_get_size_mp3buffer_t;
|
|
lame_get_frameNum : lame_get_frameNum_t;
|
|
lame_get_totalframes : lame_get_totalframes_t;
|
|
lame_init_params : lame_init_params_t;
|
|
get_lame_version : get_lame_version_t;
|
|
get_lame_short_version : get_lame_short_version_t;
|
|
get_lame_very_short_version : get_lame_very_short_version_t;
|
|
get_psy_version : get_psy_version_t;
|
|
get_lame_url : get_lame_url_t;
|
|
get_lame_version_numerical : get_lame_version_numerical_t;
|
|
lame_encode_buffer : lame_encode_buffer_t;
|
|
lame_encode_buffer_interleaved : lame_encode_buffer_interleaved_t;
|
|
lame_encode_buffer_float : lame_encode_buffer_float_t;
|
|
lame_encode_flush : lame_encode_flush_t;
|
|
lame_encode_flush_nogap : lame_encode_flush_nogap_t;
|
|
lame_init_bitstream : lame_init_bitstream_t;
|
|
lame_close : lame_close_t;
|
|
lame_decode_init : lame_decode_init_t;
|
|
lame_decode : lame_decode_t;
|
|
lame_decode_headers : lame_decode_headers_t;
|
|
lame_decode1 : lame_decode1_t;
|
|
lame_decode1_headers : lame_decode1_headers_t;
|
|
id3tag_genre_list : id3tag_genre_list_t;
|
|
id3tag_init : id3tag_init_t;
|
|
id3tag_add_v2 : id3tag_add_v2_t;
|
|
id3tag_v1_only : id3tag_v1_only_t;
|
|
id3tag_v2_only : id3tag_v2_only_t;
|
|
id3tag_space_v1 : id3tag_space_v1_t;
|
|
id3tag_pad_v2 : id3tag_pad_v2_t;
|
|
id3tag_set_title : id3tag_set_title_t;
|
|
id3tag_set_artist : id3tag_set_artist_t;
|
|
id3tag_set_album : id3tag_set_album_t;
|
|
id3tag_set_year : id3tag_set_year_t;
|
|
id3tag_set_comment : id3tag_set_comment_t;
|
|
id3tag_set_track : id3tag_set_track_t;
|
|
id3tag_set_genre : id3tag_set_genre_t;
|
|
|
|
procedure LoadLAME;
|
|
procedure UnloadLAME;
|
|
|
|
implementation
|
|
|
|
var
|
|
|
|
{$IFDEF LINUX}
|
|
Libhandle : Pointer;
|
|
{$ENDIF}
|
|
|
|
{$IFDEF WINDOWS}
|
|
Libhandle : HMODULE;
|
|
{$ENDIF}
|
|
|
|
procedure LoadLAME;
|
|
begin
|
|
if LAMELoaded then Exit;
|
|
{$IFDEF LINUX}
|
|
Libhandle := dlopen(LAME_PATH, RTLD_NOW or RTLD_GLOBAL);
|
|
if Libhandle <> nil then
|
|
begin
|
|
LAMELoaded := True;
|
|
|
|
lame_init := dlsym(Libhandle, 'lame_init');
|
|
lame_set_num_samples := dlsym(Libhandle, 'lame_set_num_samples');
|
|
lame_get_num_samples := dlsym(Libhandle, 'lame_get_num_samples');
|
|
lame_set_in_samplerate := dlsym(Libhandle, 'lame_set_in_samplerate');
|
|
lame_get_in_samplerate := dlsym(Libhandle, 'lame_get_in_samplerate');
|
|
lame_set_num_channels := dlsym(Libhandle, 'lame_set_num_channels');
|
|
lame_get_num_channels := dlsym(Libhandle, 'lame_get_num_channels');
|
|
lame_set_scale := dlsym(Libhandle, 'lame_set_scale');
|
|
lame_get_scale := dlsym(Libhandle, 'lame_get_scale');
|
|
lame_set_scale_left := dlsym(Libhandle, 'lame_set_scale_left');
|
|
lame_get_scale_left := dlsym(Libhandle, 'lame_get_scale_left');
|
|
lame_set_scale_right := dlsym(Libhandle, 'lame_set_scale_right');
|
|
lame_get_scale_right := dlsym(Libhandle, 'lame_get_scale_right');
|
|
lame_set_out_samplerate := dlsym(Libhandle, 'lame_set_out_samplerate');
|
|
lame_get_out_samplerate := dlsym(Libhandle, 'lame_get_out_samplerate');
|
|
lame_set_analysis := dlsym(Libhandle, 'lame_set_analysis');
|
|
lame_get_analysis := dlsym(Libhandle, 'lame_get_analysis');
|
|
lame_set_bWriteVbrTag := dlsym(Libhandle, 'lame_set_bWriteVbrTag');
|
|
lame_get_bWriteVbrTag := dlsym(Libhandle, 'lame_get_bWriteVbrTag');
|
|
lame_set_decode_only := dlsym(Libhandle, 'lame_set_decode_only');
|
|
lame_get_decode_only := dlsym(Libhandle, 'lame_get_decode_only');
|
|
lame_set_ogg := dlsym(Libhandle, 'lame_set_ogg');
|
|
lame_get_ogg := dlsym(Libhandle, 'lame_get_ogg');
|
|
lame_set_quality := dlsym(Libhandle, 'lame_set_quality');
|
|
lame_get_quality := dlsym(Libhandle, 'lame_get_quality');
|
|
lame_set_mode := dlsym(Libhandle, 'lame_set_mode');
|
|
lame_get_mode := dlsym(Libhandle, 'lame_get_mode');
|
|
lame_set_mode_automs := dlsym(Libhandle, 'lame_set_mode_automs');
|
|
lame_get_mode_automs := dlsym(Libhandle, 'lame_get_mode_automs');
|
|
lame_set_force_ms := dlsym(Libhandle, 'lame_set_force_ms');
|
|
lame_get_force_ms := dlsym(Libhandle, 'lame_get_force_ms');
|
|
lame_set_free_format := dlsym(Libhandle, 'lame_set_free_format');
|
|
lame_get_free_format := dlsym(Libhandle, 'lame_get_free_format');
|
|
lame_set_brate := dlsym(Libhandle, 'lame_set_brate');
|
|
lame_get_brate := dlsym(Libhandle, 'lame_get_brate');
|
|
lame_set_compression_ratio := dlsym(Libhandle, 'lame_set_compression_ratio');
|
|
lame_get_compression_ratio := dlsym(Libhandle, 'lame_get_compression_ratio');
|
|
lame_set_preset := dlsym(Libhandle, 'lame_set_preset');
|
|
lame_set_asm_optimizations := dlsym(Libhandle, 'lame_set_asm_optimizations');
|
|
lame_set_copyright := dlsym(Libhandle, 'lame_set_copyright');
|
|
lame_get_copyright := dlsym(Libhandle, 'lame_get_copyright');
|
|
lame_set_original := dlsym(Libhandle, 'lame_set_original');
|
|
lame_get_original := dlsym(Libhandle, 'lame_get_original');
|
|
lame_set_error_protection := dlsym(Libhandle, 'lame_set_error_protection');
|
|
lame_get_error_protection := dlsym(Libhandle, 'lame_get_error_protection');
|
|
lame_set_padding_type := dlsym(Libhandle, 'lame_set_padding_type');
|
|
lame_get_padding_type := dlsym(Libhandle, 'lame_get_padding_type');
|
|
lame_set_extension := dlsym(Libhandle, 'lame_set_extension');
|
|
lame_get_extension := dlsym(Libhandle, 'lame_get_extension');
|
|
lame_set_strict_ISO := dlsym(Libhandle, 'lame_set_strict_ISO');
|
|
lame_get_strict_ISO := dlsym(Libhandle, 'lame_get_strict_ISO');
|
|
lame_set_VBR := dlsym(Libhandle, 'lame_set_VBR');
|
|
lame_get_VBR := dlsym(Libhandle, 'lame_get_VBR');
|
|
lame_set_VBR_q := dlsym(Libhandle, 'lame_set_VBR_q');
|
|
lame_get_VBR_q := dlsym(Libhandle, 'lame_get_VBR_q');
|
|
lame_set_VBR_mean_bitrate_kbps := dlsym(Libhandle, 'lame_set_VBR_mean_bitrate_kbps');
|
|
lame_get_VBR_mean_bitrate_kbps := dlsym(Libhandle, 'lame_get_VBR_mean_bitrate_kbps');
|
|
lame_set_VBR_min_bitrate_kbps := dlsym(Libhandle, 'lame_set_VBR_min_bitrate_kbps');
|
|
lame_get_VBR_min_bitrate_kbps := dlsym(Libhandle, 'lame_get_VBR_min_bitrate_kbps');
|
|
lame_set_VBR_max_bitrate_kbps := dlsym(Libhandle, 'lame_set_VBR_max_bitrate_kbps');
|
|
lame_get_VBR_max_bitrate_kbps := dlsym(Libhandle, 'lame_get_VBR_max_bitrate_kbps');
|
|
lame_set_VBR_hard_min := dlsym(Libhandle, 'lame_set_VBR_hard_min');
|
|
lame_get_VBR_hard_min := dlsym(Libhandle, 'lame_get_VBR_hard_min');
|
|
lame_set_lowpassfreq := dlsym(Libhandle, 'lame_set_lowpassfreq');
|
|
lame_get_lowpassfreq := dlsym(Libhandle, 'lame_get_lowpassfreq');
|
|
lame_set_lowpasswidth := dlsym(Libhandle, 'lame_set_lowpasswidth');
|
|
lame_get_lowpasswidth := dlsym(Libhandle, 'lame_get_lowpasswidth');
|
|
lame_set_highpassfreq := dlsym(Libhandle, 'lame_set_highpassfreq');
|
|
lame_get_highpassfreq := dlsym(Libhandle, 'lame_get_highpassfreq');
|
|
lame_set_highpasswidth := dlsym(Libhandle, 'lame_set_highpasswidth');
|
|
lame_get_highpasswidth := dlsym(Libhandle, 'lame_get_highpasswidth');
|
|
lame_get_version := dlsym(Libhandle, 'lame_get_version');
|
|
lame_get_encoder_delay := dlsym(Libhandle, 'lame_get_encoder_delay');
|
|
lame_get_encoder_padding := dlsym(Libhandle, 'lame_get_encoder_padding');
|
|
lame_get_framesize := dlsym(Libhandle, 'lame_get_framesize');
|
|
lame_get_mf_samples_to_encode := dlsym(Libhandle, 'lame_get_mf_samples_to_encode');
|
|
lame_get_size_mp3buffer := dlsym(Libhandle, 'lame_get_size_mp3buffer');
|
|
lame_get_frameNum := dlsym(Libhandle, 'lame_get_frameNum');
|
|
lame_get_totalframes := dlsym(Libhandle, 'lame_get_totalframes');
|
|
lame_init_params := dlsym(Libhandle, 'lame_init_params');
|
|
get_lame_version := dlsym(Libhandle, 'get_lame_version');
|
|
get_lame_short_version := dlsym(Libhandle, 'get_lame_short_version');
|
|
get_lame_very_short_version := dlsym(Libhandle, 'get_lame_very_short_version');
|
|
get_psy_version := dlsym(Libhandle, 'get_psy_version');
|
|
get_lame_url := dlsym(Libhandle, 'get_lame_url');
|
|
get_lame_version_numerical := dlsym(Libhandle, 'get_lame_version_numerical');
|
|
lame_encode_buffer := dlsym(Libhandle, 'lame_encode_buffer');
|
|
lame_encode_buffer_interleaved := dlsym(Libhandle, 'lame_encode_buffer_interleaved');
|
|
lame_encode_buffer_float := dlsym(Libhandle, 'lame_encode_buffer_float');
|
|
lame_encode_flush := dlsym(Libhandle, 'lame_encode_flush');
|
|
lame_encode_flush_nogap := dlsym(Libhandle, 'lame_encode_flush_nogap');
|
|
lame_init_bitstream := dlsym(Libhandle, 'lame_init_bitstream');
|
|
lame_close := dlsym(Libhandle, 'lame_close');
|
|
lame_decode_init := dlsym(Libhandle, 'lame_decode_init');
|
|
lame_decode := dlsym(Libhandle, 'lame_decode');
|
|
lame_decode_headers := dlsym(Libhandle, 'lame_decode_headers');
|
|
lame_decode1 := dlsym(Libhandle, 'lame_decode1');
|
|
lame_decode1_headers := dlsym(Libhandle, 'lame_decode1_headers');
|
|
id3tag_genre_list := dlsym(Libhandle, 'id3tag_genre_list');
|
|
id3tag_init := dlsym(Libhandle, 'id3tag_init');
|
|
id3tag_add_v2 := dlsym(Libhandle, 'id3tag_add_v2');
|
|
id3tag_v1_only := dlsym(Libhandle, 'id3tag_v1_only');
|
|
id3tag_v2_only := dlsym(Libhandle, 'id3tag_v2_only');
|
|
id3tag_space_v1 := dlsym(Libhandle, 'id3tag_space_v1');
|
|
id3tag_pad_v2 := dlsym(Libhandle, 'id3tag_pad_v2');
|
|
id3tag_set_title := dlsym(Libhandle, 'id3tag_set_title');
|
|
id3tag_set_artist := dlsym(Libhandle, 'id3tag_set_artist');
|
|
id3tag_set_album := dlsym(Libhandle, 'id3tag_set_album');
|
|
id3tag_set_year := dlsym(Libhandle, 'id3tag_set_year');
|
|
id3tag_set_comment := dlsym(Libhandle, 'id3tag_set_comment');
|
|
id3tag_set_track := dlsym(Libhandle, 'id3tag_set_track');
|
|
id3tag_set_genre := dlsym(Libhandle, 'id3tag_set_genre');
|
|
end;
|
|
{$ENDIF}
|
|
|
|
{$IFDEF WIN32}
|
|
Libhandle := LoadLibraryEx(LAME_PATH, 0, 0);
|
|
if Libhandle <> 0 then
|
|
begin
|
|
LAMELoaded := True;
|
|
|
|
lame_init := GetProcAddress(Libhandle, 'lame_init');
|
|
lame_set_num_samples := GetProcAddress(Libhandle, 'lame_set_num_samples');
|
|
lame_get_num_samples := GetProcAddress(Libhandle, 'lame_get_num_samples');
|
|
lame_set_in_samplerate := GetProcAddress(Libhandle, 'lame_set_in_samplerate');
|
|
lame_get_in_samplerate := GetProcAddress(Libhandle, 'lame_get_in_samplerate');
|
|
lame_set_num_channels := GetProcAddress(Libhandle, 'lame_set_num_channels');
|
|
lame_get_num_channels := GetProcAddress(Libhandle, 'lame_get_num_channels');
|
|
lame_set_scale := GetProcAddress(Libhandle, 'lame_set_scale');
|
|
lame_get_scale := GetProcAddress(Libhandle, 'lame_get_scale');
|
|
lame_set_scale_left := GetProcAddress(Libhandle, 'lame_set_scale_left');
|
|
lame_get_scale_left := GetProcAddress(Libhandle, 'lame_get_scale_left');
|
|
lame_set_scale_right := GetProcAddress(Libhandle, 'lame_set_scale_right');
|
|
lame_get_scale_right := GetProcAddress(Libhandle, 'lame_get_scale_right');
|
|
lame_set_out_samplerate := GetProcAddress(Libhandle, 'lame_set_out_samplerate');
|
|
lame_get_out_samplerate := GetProcAddress(Libhandle, 'lame_get_out_samplerate');
|
|
lame_set_analysis := GetProcAddress(Libhandle, 'lame_set_analysis');
|
|
lame_get_analysis := GetProcAddress(Libhandle, 'lame_get_analysis');
|
|
lame_set_bWriteVbrTag := GetProcAddress(Libhandle, 'lame_set_bWriteVbrTag');
|
|
lame_get_bWriteVbrTag := GetProcAddress(Libhandle, 'lame_get_bWriteVbrTag');
|
|
lame_set_decode_only := GetProcAddress(Libhandle, 'lame_set_decode_only');
|
|
lame_get_decode_only := GetProcAddress(Libhandle, 'lame_get_decode_only');
|
|
lame_set_ogg := GetProcAddress(Libhandle, 'lame_set_ogg');
|
|
lame_get_ogg := GetProcAddress(Libhandle, 'lame_get_ogg');
|
|
lame_set_quality := GetProcAddress(Libhandle, 'lame_set_quality');
|
|
lame_get_quality := GetProcAddress(Libhandle, 'lame_get_quality');
|
|
lame_set_mode := GetProcAddress(Libhandle, 'lame_set_mode');
|
|
lame_get_mode := GetProcAddress(Libhandle, 'lame_get_mode');
|
|
lame_set_mode_automs := GetProcAddress(Libhandle, 'lame_set_mode_automs');
|
|
lame_get_mode_automs := GetProcAddress(Libhandle, 'lame_get_mode_automs');
|
|
lame_set_force_ms := GetProcAddress(Libhandle, 'lame_set_force_ms');
|
|
lame_get_force_ms := GetProcAddress(Libhandle, 'lame_get_force_ms');
|
|
lame_set_free_format := GetProcAddress(Libhandle, 'lame_set_free_format');
|
|
lame_get_free_format := GetProcAddress(Libhandle, 'lame_get_free_format');
|
|
lame_set_brate := GetProcAddress(Libhandle, 'lame_set_brate');
|
|
lame_get_brate := GetProcAddress(Libhandle, 'lame_get_brate');
|
|
lame_set_compression_ratio := GetProcAddress(Libhandle, 'lame_set_compression_ratio');
|
|
lame_get_compression_ratio := GetProcAddress(Libhandle, 'lame_get_compression_ratio');
|
|
lame_set_preset := GetProcAddress(Libhandle, 'lame_set_preset');
|
|
lame_set_asm_optimizations := GetProcAddress(Libhandle, 'lame_set_asm_optimizations');
|
|
lame_set_copyright := GetProcAddress(Libhandle, 'lame_set_copyright');
|
|
lame_get_copyright := GetProcAddress(Libhandle, 'lame_get_copyright');
|
|
lame_set_original := GetProcAddress(Libhandle, 'lame_set_original');
|
|
lame_get_original := GetProcAddress(Libhandle, 'lame_get_original');
|
|
lame_set_error_protection := GetProcAddress(Libhandle, 'lame_set_error_protection');
|
|
lame_get_error_protection := GetProcAddress(Libhandle, 'lame_get_error_protection');
|
|
lame_set_padding_type := GetProcAddress(Libhandle, 'lame_set_padding_type');
|
|
lame_get_padding_type := GetProcAddress(Libhandle, 'lame_get_padding_type');
|
|
lame_set_extension := GetProcAddress(Libhandle, 'lame_set_extension');
|
|
lame_get_extension := GetProcAddress(Libhandle, 'lame_get_extension');
|
|
lame_set_strict_ISO := GetProcAddress(Libhandle, 'lame_set_strict_ISO');
|
|
lame_get_strict_ISO := GetProcAddress(Libhandle, 'lame_get_strict_ISO');
|
|
lame_set_VBR := GetProcAddress(Libhandle, 'lame_set_VBR');
|
|
lame_get_VBR := GetProcAddress(Libhandle, 'lame_get_VBR');
|
|
lame_set_VBR_q := GetProcAddress(Libhandle, 'lame_set_VBR_q');
|
|
lame_get_VBR_q := GetProcAddress(Libhandle, 'lame_get_VBR_q');
|
|
lame_set_VBR_mean_bitrate_kbps := GetProcAddress(Libhandle, 'lame_set_VBR_mean_bitrate_kbps');
|
|
lame_get_VBR_mean_bitrate_kbps := GetProcAddress(Libhandle, 'lame_get_VBR_mean_bitrate_kbps');
|
|
lame_set_VBR_min_bitrate_kbps := GetProcAddress(Libhandle, 'lame_set_VBR_min_bitrate_kbps');
|
|
lame_get_VBR_min_bitrate_kbps := GetProcAddress(Libhandle, 'lame_get_VBR_min_bitrate_kbps');
|
|
lame_set_VBR_max_bitrate_kbps := GetProcAddress(Libhandle, 'lame_set_VBR_max_bitrate_kbps');
|
|
lame_get_VBR_max_bitrate_kbps := GetProcAddress(Libhandle, 'lame_get_VBR_max_bitrate_kbps');
|
|
lame_set_VBR_hard_min := GetProcAddress(Libhandle, 'lame_set_VBR_hard_min');
|
|
lame_get_VBR_hard_min := GetProcAddress(Libhandle, 'lame_get_VBR_hard_min');
|
|
lame_set_lowpassfreq := GetProcAddress(Libhandle, 'lame_set_lowpassfreq');
|
|
lame_get_lowpassfreq := GetProcAddress(Libhandle, 'lame_get_lowpassfreq');
|
|
lame_set_lowpasswidth := GetProcAddress(Libhandle, 'lame_set_lowpasswidth');
|
|
lame_get_lowpasswidth := GetProcAddress(Libhandle, 'lame_get_lowpasswidth');
|
|
lame_set_highpassfreq := GetProcAddress(Libhandle, 'lame_set_highpassfreq');
|
|
lame_get_highpassfreq := GetProcAddress(Libhandle, 'lame_get_highpassfreq');
|
|
lame_set_highpasswidth := GetProcAddress(Libhandle, 'lame_set_highpasswidth');
|
|
lame_get_highpasswidth := GetProcAddress(Libhandle, 'lame_get_highpasswidth');
|
|
lame_get_version := GetProcAddress(Libhandle, 'lame_get_version');
|
|
lame_get_encoder_delay := GetProcAddress(Libhandle, 'lame_get_encoder_delay');
|
|
lame_get_encoder_padding := GetProcAddress(Libhandle, 'lame_get_encoder_padding');
|
|
lame_get_framesize := GetProcAddress(Libhandle, 'lame_get_framesize');
|
|
lame_get_mf_samples_to_encode := GetProcAddress(Libhandle, 'lame_get_mf_samples_to_encode');
|
|
lame_get_size_mp3buffer := GetProcAddress(Libhandle, 'lame_get_size_mp3buffer');
|
|
lame_get_frameNum := GetProcAddress(Libhandle, 'lame_get_frameNum');
|
|
lame_get_totalframes := GetProcAddress(Libhandle, 'lame_get_totalframes');
|
|
lame_init_params := GetProcAddress(Libhandle, 'lame_init_params');
|
|
get_lame_version := GetProcAddress(Libhandle, 'get_lame_version');
|
|
get_lame_short_version := GetProcAddress(Libhandle, 'get_lame_short_version');
|
|
get_lame_very_short_version := GetProcAddress(Libhandle, 'get_lame_very_short_version');
|
|
get_psy_version := GetProcAddress(Libhandle, 'get_psy_version');
|
|
get_lame_url := GetProcAddress(Libhandle, 'get_lame_url');
|
|
get_lame_version_numerical := GetProcAddress(Libhandle, 'get_lame_version_numerical');
|
|
lame_encode_buffer := GetProcAddress(Libhandle, 'lame_encode_buffer');
|
|
lame_encode_buffer_interleaved := GetProcAddress(Libhandle, 'lame_encode_buffer_interleaved');
|
|
lame_encode_buffer_float := GetProcAddress(Libhandle, 'lame_encode_buffer_float');
|
|
lame_encode_flush := GetProcAddress(Libhandle, 'lame_encode_flush');
|
|
lame_encode_flush_nogap := GetProcAddress(Libhandle, 'lame_encode_flush_nogap');
|
|
lame_init_bitstream := GetProcAddress(Libhandle, 'lame_init_bitstream');
|
|
lame_close := GetProcAddress(Libhandle, 'lame_close');
|
|
lame_decode_init := GetProcAddress(Libhandle, 'lame_decode_init');
|
|
lame_decode := GetProcAddress(Libhandle, 'lame_decode');
|
|
lame_decode_headers := GetProcAddress(Libhandle, 'lame_decode_headers');
|
|
lame_decode1 := GetProcAddress(Libhandle, 'lame_decode1');
|
|
lame_decode1_headers := GetProcAddress(Libhandle, 'lame_decode1_headers');
|
|
id3tag_genre_list := GetProcAddress(Libhandle, 'id3tag_genre_list');
|
|
id3tag_init := GetProcAddress(Libhandle, 'id3tag_init');
|
|
id3tag_add_v2 := GetProcAddress(Libhandle, 'id3tag_add_v2');
|
|
id3tag_v1_only := GetProcAddress(Libhandle, 'id3tag_v1_only');
|
|
id3tag_v2_only := GetProcAddress(Libhandle, 'id3tag_v2_only');
|
|
id3tag_space_v1 := GetProcAddress(Libhandle, 'id3tag_space_v1');
|
|
id3tag_pad_v2 := GetProcAddress(Libhandle, 'id3tag_pad_v2');
|
|
id3tag_set_title := GetProcAddress(Libhandle, 'id3tag_set_title');
|
|
id3tag_set_artist := GetProcAddress(Libhandle, 'id3tag_set_artist');
|
|
id3tag_set_album := GetProcAddress(Libhandle, 'id3tag_set_album');
|
|
id3tag_set_year := GetProcAddress(Libhandle, 'id3tag_set_year');
|
|
id3tag_set_comment := GetProcAddress(Libhandle, 'id3tag_set_comment');
|
|
id3tag_set_track := GetProcAddress(Libhandle, 'id3tag_set_track');
|
|
id3tag_set_genre := GetProcAddress(Libhandle, 'id3tag_set_genre');
|
|
end;
|
|
{$ENDIF}
|
|
end;
|
|
|
|
procedure UnloadLAME;
|
|
begin
|
|
|
|
LAMELoaded := False;
|
|
|
|
{$IFDEF LINUX}
|
|
if Libhandle <> nil then dlclose(Libhandle);
|
|
{$ENDIF}
|
|
|
|
{$IFDEF WIN32}
|
|
if Libhandle <> 0 then FreeLibrary(Libhandle);
|
|
{$ENDIF}
|
|
|
|
end;
|
|
end.
|