de.sciss.jump3r.mp3

Class Lame

java.lang.Object

de.sciss.jump3r.mp3.Lame

public class Lame
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	Lame.InOut
protected static class	Lame.LowPassHighPass
protected static class	Lame.NumUsed

Field Summary

Fields

Modifier and Type	Field and Description
Encoder	enc
static int	EXTREME
static int	EXTREME_FAST
static int	INSANE
static long	LAME_ID
static int	LAME_MAXMP3BUFFER maximum size of mp3buffer needed if you encode at most 1152 samples for each call to lame_encode_buffer.
static int	MEDIUM
static int	MEDIUM_FAST
static int	R3MIX
static int	STANDARD
static int	STANDARD_FAST
static int	V0
static int	V1
static int	V2
static int	V3
static int	V4
static int	V5
static int	V6
static int	V7
static int	V8
static int	V9

Constructor Summary

Constructors

Constructor and Description
Lame()

Method Summary

Modifier and Type	Method and Description
int	BitrateIndex(int bRate, int version, int samplerate)
void	lame_bitrate_block_type_hist(LameGlobalFlags gfp, int[][] bitrate_btype_count)
void	lame_bitrate_hist(LameGlobalFlags gfp, int[] bitrate_count)
void	lame_bitrate_kbps(LameGlobalFlags gfp, int[] bitrate_kbps) histogram of used bitrate indexes: One has to weight them to calculate the average bitrate in kbps bitrate indices: there are 14 possible bitrate indices, 0 has the special meaning "free format" which is not possible to mix with VBR and 15 is forbidden anyway.
void	lame_bitrate_stereo_mode_hist(LameGlobalFlags gfp, int[][] bitrate_stmode_count)
void	lame_block_type_hist(LameGlobalFlags gfp, int[] btype_count)
int	lame_close(LameGlobalFlags gfp) frees internal buffers
int	lame_encode_buffer_int(LameGlobalFlags gfp, int[] buffer_l, int[] buffer_r, int nsamples, byte[] mp3buf, int mp3bufPos, int mp3buf_size)
int	lame_encode_flush_nogap(LameGlobalFlags gfp, byte[] mp3buffer, int mp3buffer_size) Flush mp3 buffer, pad with ancillary data so last frame is complete.
int	lame_encode_flush(LameGlobalFlags gfp, byte[] mp3buffer, int mp3bufferPos, int mp3buffer_size) flush internal PCM sample buffers, then mp3 buffers then write id3 v1 tags into bitstream.
void	lame_init_bitstream(LameGlobalFlags gfp)
int	lame_init_params(LameGlobalFlags gfp) initialize internal params based on data in gf (globalflags struct filled in by calling program) OUTLINE: We first have some complex code to determine bitrate, output samplerate and mode.
LameGlobalFlags	lame_init()
void	lame_print_config(LameGlobalFlags gfp) Prints some selected information about the coding parameters via the macro command MSGF(), which is currently mapped to lame_errorf (reports via a error function?), which is a printf-like function for .
void	lame_print_internals(LameGlobalFlags gfp) rh: some pretty printing is very welcome at this point! so, if someone is willing to do so, please do it! add more, if you see more...
void	lame_stereo_mode_hist(LameGlobalFlags gfp, int[] stmode_count)
int	nearestBitrateFullIndex(int bitrate) Used to find table index when we need bitrate-based values determined using tables bitrate in kbps Gabriel Bouvigne 2002-11-03
void	setModules(GainAnalysis ga, BitStream bs, Presets p, QuantizePVT qupvt, Quantize qu, VBRTag vbr, Version ver, ID3Tag id3, MPGLib mpglib)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

enc

public Encoder enc

LAME_ID

public static final long LAME_ID

See Also:

Constant Field Values

V9

public static final int V9

See Also:

Constant Field Values

V8

public static final int V8

See Also:

Constant Field Values

V7

public static final int V7

See Also:

Constant Field Values

V6

public static final int V6

See Also:

Constant Field Values

V5

public static final int V5

See Also:

Constant Field Values

V4

public static final int V4

See Also:

Constant Field Values

V3

public static final int V3

See Also:

Constant Field Values

V2

public static final int V2

See Also:

Constant Field Values

V1

public static final int V1

See Also:

Constant Field Values

V0

public static final int V0

See Also:

Constant Field Values

R3MIX

public static final int R3MIX

See Also:

Constant Field Values

STANDARD

public static final int STANDARD

See Also:

Constant Field Values

EXTREME

public static final int EXTREME

See Also:

Constant Field Values

INSANE

public static final int INSANE

See Also:

Constant Field Values

STANDARD_FAST

public static final int STANDARD_FAST

See Also:

Constant Field Values

EXTREME_FAST

public static final int EXTREME_FAST

See Also:

Constant Field Values

MEDIUM

public static final int MEDIUM

See Also:

Constant Field Values

MEDIUM_FAST

public static final int MEDIUM_FAST

See Also:

Constant Field Values

LAME_MAXMP3BUFFER

public static final int LAME_MAXMP3BUFFER

maximum size of mp3buffer needed if you encode at most 1152 samples for each call to lame_encode_buffer. see lame_encode_buffer() below (LAME_MAXMP3BUFFER is now obsolete)

See Also:

Constant Field Values

Constructor Detail

Lame

public Lame()

Method Detail

setModules

public final void setModules(GainAnalysis ga,
                             BitStream bs,
                             Presets p,
                             QuantizePVT qupvt,
                             Quantize qu,
                             VBRTag vbr,
                             Version ver,
                             ID3Tag id3,
                             MPGLib mpglib)

nearestBitrateFullIndex

public final int nearestBitrateFullIndex(int bitrate)

Used to find table index when we need bitrate-based values determined using tables bitrate in kbps Gabriel Bouvigne 2002-11-03

BitrateIndex

public final int BitrateIndex(int bRate,
                              int version,
                              int samplerate)

Parameters:

bRate - legal rates from 32 to 448 kbps

version - MPEG-1 or MPEG-2/2.5 LSF

lame_init_params

public final int lame_init_params(LameGlobalFlags gfp)

initialize internal params based on data in gf (globalflags struct filled in by calling program) OUTLINE: We first have some complex code to determine bitrate, output samplerate and mode. It is complicated by the fact that we allow the user to set some or all of these parameters, and need to determine best possible values for the rest of them: 1. set some CPU related flags 2. check if we are mono.mono, stereo.mono or stereo.stereo 3. compute bitrate and output samplerate: user may have set compression ratio user may have set a bitrate user may have set a output samplerate 4. set some options which depend on output samplerate 5. compute the actual compression ratio 6. set mode based on compression ratio The remaining code is much simpler - it just sets options based on the mode & compression ratio: set allow_diff_short based on mode select lowpass filter based on compression ratio & mode set the bitrate index, and min/max bitrates for VBR modes disable VBR tag if it is not appropriate initialize the bitstream initialize scalefac_band data set sideinfo_len (based on channels, CRC, out_samplerate) write an id3v2 tag into the bitstream write VBR tag into the bitstream set mpeg1/2 flag estimate the number of frames (based on a lot of data) now we set more flags: nspsytune: see code VBR modes see code CBR/ABR see code Finally, we set the algorithm flags based on the gfp.quality value lame_init_qval(gfp);

lame_print_config

public final void lame_print_config(LameGlobalFlags gfp)

Prints some selected information about the coding parameters via the macro command MSGF(), which is currently mapped to lame_errorf (reports via a error function?), which is a printf-like function for .

lame_print_internals

public final void lame_print_internals(LameGlobalFlags gfp)

rh: some pretty printing is very welcome at this point! so, if someone is willing to do so, please do it! add more, if you see more...

lame_encode_buffer_int

public int lame_encode_buffer_int(LameGlobalFlags gfp,
                                  int[] buffer_l,
                                  int[] buffer_r,
                                  int nsamples,
                                  byte[] mp3buf,
                                  int mp3bufPos,
                                  int mp3buf_size)

lame_encode_flush_nogap

public final int lame_encode_flush_nogap(LameGlobalFlags gfp,
                                         byte[] mp3buffer,
                                         int mp3buffer_size)

Flush mp3 buffer, pad with ancillary data so last frame is complete. Reset reservoir size to 0 but keep all PCM samples and MDCT data in memory This option is used to break a large file into several mp3 files that when concatenated together will decode with no gaps Because we set the reservoir=0, they will also decode seperately with no errors.

lame_init_bitstream

public final void lame_init_bitstream(LameGlobalFlags gfp)

lame_encode_flush

public final int lame_encode_flush(LameGlobalFlags gfp,
                                   byte[] mp3buffer,
                                   int mp3bufferPos,
                                   int mp3buffer_size)

flush internal PCM sample buffers, then mp3 buffers then write id3 v1 tags into bitstream.

lame_close

public final int lame_close(LameGlobalFlags gfp)

frees internal buffers

lame_init

public final LameGlobalFlags lame_init()

lame_bitrate_kbps

public final void lame_bitrate_kbps(LameGlobalFlags gfp,
                                    int[] bitrate_kbps)

  histogram of used bitrate indexes:
  One has to weight them to calculate the average bitrate in kbps
 
  bitrate indices:
  there are 14 possible bitrate indices, 0 has the special meaning
  "free format" which is not possible to mix with VBR and 15 is forbidden
  anyway.
 
  stereo modes:
  0: LR   number of left-right encoded frames
  1: LR-I number of left-right and intensity encoded frames
  2: MS   number of mid-side encoded frames
  3: MS-I number of mid-side and intensity encoded frames
 
  4: number of encoded frames
 

lame_bitrate_hist

public final void lame_bitrate_hist(LameGlobalFlags gfp,
                                    int[] bitrate_count)

lame_stereo_mode_hist

public final void lame_stereo_mode_hist(LameGlobalFlags gfp,
                                        int[] stmode_count)

lame_bitrate_stereo_mode_hist

public final void lame_bitrate_stereo_mode_hist(LameGlobalFlags gfp,
                                                int[][] bitrate_stmode_count)

lame_block_type_hist

public final void lame_block_type_hist(LameGlobalFlags gfp,
                                       int[] btype_count)

lame_bitrate_block_type_hist

public final void lame_bitrate_block_type_hist(LameGlobalFlags gfp,
                                               int[][] bitrate_btype_count)