|
|
@@ -0,0 +1,1323 @@
|
|
|
+/*
|
|
|
+ * Interface to MP3 LAME encoding engine
|
|
|
+ *
|
|
|
+ * Copyright (c) 1999 Mark Taylor
|
|
|
+ *
|
|
|
+ * This library is free software; you can redistribute it and/or
|
|
|
+ * modify it under the terms of the GNU Library General Public
|
|
|
+ * License as published by the Free Software Foundation; either
|
|
|
+ * version 2 of the License, or (at your option) any later version.
|
|
|
+ *
|
|
|
+ * This library is distributed in the hope that it will be useful,
|
|
|
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
+ * Library General Public License for more details.
|
|
|
+ *
|
|
|
+ * You should have received a copy of the GNU Library General Public
|
|
|
+ * License along with this library; if not, write to the
|
|
|
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
+ * Boston, MA 02111-1307, USA.
|
|
|
+ */
|
|
|
+
|
|
|
+/* $Id: lame.h,v 1.189.2.1 2012/01/08 23:49:58 robert Exp $ */
|
|
|
+
|
|
|
+#ifndef LAME_LAME_H
|
|
|
+#define LAME_LAME_H
|
|
|
+
|
|
|
+/* for size_t typedef */
|
|
|
+#include <stddef.h>
|
|
|
+/* for va_list typedef */
|
|
|
+#include <stdarg.h>
|
|
|
+/* for FILE typedef, TODO: remove when removing lame_mp3_tags_fid */
|
|
|
+#include <stdio.h>
|
|
|
+
|
|
|
+#if defined(__cplusplus)
|
|
|
+extern "C" {
|
|
|
+#endif
|
|
|
+
|
|
|
+typedef void (*lame_report_function)(const char *format, va_list ap);
|
|
|
+
|
|
|
+#if defined(WIN32) || defined(_WIN32)
|
|
|
+#undef CDECL
|
|
|
+#define CDECL __cdecl
|
|
|
+#else
|
|
|
+#define CDECL
|
|
|
+#endif
|
|
|
+
|
|
|
+#define DEPRECATED_OR_OBSOLETE_CODE_REMOVED 1
|
|
|
+
|
|
|
+typedef enum vbr_mode_e {
|
|
|
+ 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_mtrh /* change this to change the default VBR mode of LAME */
|
|
|
+} vbr_mode;
|
|
|
+
|
|
|
+
|
|
|
+/* MPEG modes */
|
|
|
+typedef enum MPEG_mode_e {
|
|
|
+ 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. */
|
|
|
+} MPEG_mode;
|
|
|
+
|
|
|
+/* Padding types */
|
|
|
+typedef enum Padding_type_e {
|
|
|
+ PAD_NO = 0,
|
|
|
+ PAD_ALL,
|
|
|
+ PAD_ADJUST,
|
|
|
+ PAD_MAX_INDICATOR /* Don't use this! It's used for sanity checks. */
|
|
|
+} Padding_type;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/*presets*/
|
|
|
+typedef enum preset_mode_e {
|
|
|
+ /*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,
|
|
|
+
|
|
|
+ V9 = 410, /*Vx to match Lame and VBR_xx to match FhG*/
|
|
|
+ VBR_10 = 410,
|
|
|
+ V8 = 420,
|
|
|
+ VBR_20 = 420,
|
|
|
+ V7 = 430,
|
|
|
+ VBR_30 = 430,
|
|
|
+ V6 = 440,
|
|
|
+ VBR_40 = 440,
|
|
|
+ V5 = 450,
|
|
|
+ VBR_50 = 450,
|
|
|
+ V4 = 460,
|
|
|
+ VBR_60 = 460,
|
|
|
+ V3 = 470,
|
|
|
+ VBR_70 = 470,
|
|
|
+ V2 = 480,
|
|
|
+ VBR_80 = 480,
|
|
|
+ V1 = 490,
|
|
|
+ VBR_90 = 490,
|
|
|
+ V0 = 500,
|
|
|
+ VBR_100 = 500,
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ /*still there for compatibility*/
|
|
|
+ R3MIX = 1000,
|
|
|
+ STANDARD = 1001,
|
|
|
+ EXTREME = 1002,
|
|
|
+ INSANE = 1003,
|
|
|
+ STANDARD_FAST = 1004,
|
|
|
+ EXTREME_FAST = 1005,
|
|
|
+ MEDIUM = 1006,
|
|
|
+ MEDIUM_FAST = 1007
|
|
|
+} preset_mode;
|
|
|
+
|
|
|
+
|
|
|
+/*asm optimizations*/
|
|
|
+typedef enum asm_optimizations_e {
|
|
|
+ MMX = 1,
|
|
|
+ AMD_3DNOW = 2,
|
|
|
+ SSE = 3
|
|
|
+} asm_optimizations;
|
|
|
+
|
|
|
+
|
|
|
+/* psychoacoustic model */
|
|
|
+typedef enum Psy_model_e {
|
|
|
+ PSY_GPSYCHO = 1,
|
|
|
+ PSY_NSPSYTUNE = 2
|
|
|
+} Psy_model;
|
|
|
+
|
|
|
+
|
|
|
+/* buffer considerations */
|
|
|
+typedef enum buffer_constraint_e {
|
|
|
+ MDB_DEFAULT=0,
|
|
|
+ MDB_STRICT_ISO=1,
|
|
|
+ MDB_MAXIMUM=2
|
|
|
+} buffer_constraint;
|
|
|
+
|
|
|
+
|
|
|
+struct lame_global_struct;
|
|
|
+typedef struct lame_global_struct lame_global_flags;
|
|
|
+typedef lame_global_flags *lame_t;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/***********************************************************************
|
|
|
+ *
|
|
|
+ * The LAME API
|
|
|
+ * These functions should be called, in this order, for each
|
|
|
+ * MP3 file to be encoded. See the file "API" for more documentation
|
|
|
+ *
|
|
|
+ ***********************************************************************/
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * REQUIRED:
|
|
|
+ * initialize the encoder. sets default for all encoder parameters,
|
|
|
+ * returns NULL if some malloc()'s failed
|
|
|
+ * otherwise returns pointer to structure needed for all future
|
|
|
+ * API calls.
|
|
|
+ */
|
|
|
+lame_global_flags * CDECL lame_init(void);
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/* obsolete version */
|
|
|
+int CDECL lame_init_old(lame_global_flags *);
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ * OPTIONAL:
|
|
|
+ * set as needed to override defaults
|
|
|
+ */
|
|
|
+
|
|
|
+/********************************************************************
|
|
|
+ * input stream description
|
|
|
+ ***********************************************************************/
|
|
|
+/* number of samples. default = 2^32-1 */
|
|
|
+int CDECL lame_set_num_samples(lame_global_flags *, unsigned long);
|
|
|
+unsigned long CDECL lame_get_num_samples(const lame_global_flags *);
|
|
|
+
|
|
|
+/* input sample rate in Hz. default = 44100hz */
|
|
|
+int CDECL lame_set_in_samplerate(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_in_samplerate(const lame_global_flags *);
|
|
|
+
|
|
|
+/* number of channels in input stream. default=2 */
|
|
|
+int CDECL lame_set_num_channels(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_num_channels(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ scale the input by this amount before encoding. default=1
|
|
|
+ (not used by decoding routines)
|
|
|
+*/
|
|
|
+int CDECL lame_set_scale(lame_global_flags *, float);
|
|
|
+float CDECL lame_get_scale(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ scale the channel 0 (left) input by this amount before encoding. default=1
|
|
|
+ (not used by decoding routines)
|
|
|
+*/
|
|
|
+int CDECL lame_set_scale_left(lame_global_flags *, float);
|
|
|
+float CDECL lame_get_scale_left(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ scale the channel 1 (right) input by this amount before encoding. default=1
|
|
|
+ (not used by decoding routines)
|
|
|
+*/
|
|
|
+int CDECL lame_set_scale_right(lame_global_flags *, float);
|
|
|
+float CDECL lame_get_scale_right(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ 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)
|
|
|
+*/
|
|
|
+int CDECL lame_set_out_samplerate(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_out_samplerate(const lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+/********************************************************************
|
|
|
+ * general control parameters
|
|
|
+ ***********************************************************************/
|
|
|
+/* 1=cause LAME to collect data for an MP3 frame analyzer. default=0 */
|
|
|
+int CDECL lame_set_analysis(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_analysis(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ 1 = write a Xing VBR header frame.
|
|
|
+ default = 1
|
|
|
+ this variable must have been added by a Hungarian notation Windows programmer :-)
|
|
|
+*/
|
|
|
+int CDECL lame_set_bWriteVbrTag(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_bWriteVbrTag(const lame_global_flags *);
|
|
|
+
|
|
|
+/* 1=decode only. use lame/mpglib to convert mp3/ogg to wav. default=0 */
|
|
|
+int CDECL lame_set_decode_only(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_decode_only(const lame_global_flags *);
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/* 1=encode a Vorbis .ogg file. default=0 */
|
|
|
+/* DEPRECATED */
|
|
|
+int CDECL lame_set_ogg(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_ogg(const lame_global_flags *);
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ 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
|
|
|
+*/
|
|
|
+int CDECL lame_set_quality(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_quality(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ mode = 0,1,2,3 = stereo, jstereo, dual channel (not supported), mono
|
|
|
+ default: lame picks based on compression ration and input channels
|
|
|
+*/
|
|
|
+int CDECL lame_set_mode(lame_global_flags *, MPEG_mode);
|
|
|
+MPEG_mode CDECL lame_get_mode(const lame_global_flags *);
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/*
|
|
|
+ mode_automs. Use a M/S mode with a switching threshold based on
|
|
|
+ compression ratio
|
|
|
+ DEPRECATED
|
|
|
+*/
|
|
|
+int CDECL lame_set_mode_automs(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_mode_automs(const lame_global_flags *);
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ force_ms. Force M/S for all frames. For testing only.
|
|
|
+ default = 0 (disabled)
|
|
|
+*/
|
|
|
+int CDECL lame_set_force_ms(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_force_ms(const lame_global_flags *);
|
|
|
+
|
|
|
+/* use free_format? default = 0 (disabled) */
|
|
|
+int CDECL lame_set_free_format(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_free_format(const lame_global_flags *);
|
|
|
+
|
|
|
+/* perform ReplayGain analysis? default = 0 (disabled) */
|
|
|
+int CDECL lame_set_findReplayGain(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_findReplayGain(const lame_global_flags *);
|
|
|
+
|
|
|
+/* decode on the fly. Search for the peak sample. If the ReplayGain
|
|
|
+ * analysis is enabled then perform the analysis on the decoded data
|
|
|
+ * stream. default = 0 (disabled)
|
|
|
+ * NOTE: if this option is set the build-in decoder should not be used */
|
|
|
+int CDECL lame_set_decode_on_the_fly(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_decode_on_the_fly(const lame_global_flags *);
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/* DEPRECATED: now does the same as lame_set_findReplayGain()
|
|
|
+ default = 0 (disabled) */
|
|
|
+int CDECL lame_set_ReplayGain_input(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_ReplayGain_input(const lame_global_flags *);
|
|
|
+
|
|
|
+/* DEPRECATED: now does the same as
|
|
|
+ lame_set_decode_on_the_fly() && lame_set_findReplayGain()
|
|
|
+ default = 0 (disabled) */
|
|
|
+int CDECL lame_set_ReplayGain_decode(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_ReplayGain_decode(const lame_global_flags *);
|
|
|
+
|
|
|
+/* DEPRECATED: now does the same as lame_set_decode_on_the_fly()
|
|
|
+ default = 0 (disabled) */
|
|
|
+int CDECL lame_set_findPeakSample(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_findPeakSample(const lame_global_flags *);
|
|
|
+#endif
|
|
|
+
|
|
|
+/* counters for gapless encoding */
|
|
|
+int CDECL lame_set_nogap_total(lame_global_flags*, int);
|
|
|
+int CDECL lame_get_nogap_total(const lame_global_flags*);
|
|
|
+
|
|
|
+int CDECL lame_set_nogap_currentindex(lame_global_flags* , int);
|
|
|
+int CDECL lame_get_nogap_currentindex(const lame_global_flags*);
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * OPTIONAL:
|
|
|
+ * Set printf like error/debug/message reporting functions.
|
|
|
+ * The second argument has to be a pointer to a function which looks like
|
|
|
+ * void my_debugf(const char *format, va_list ap)
|
|
|
+ * {
|
|
|
+ * (void) vfprintf(stdout, format, ap);
|
|
|
+ * }
|
|
|
+ * If you use NULL as the value of the pointer in the set function, the
|
|
|
+ * lame buildin function will be used (prints to stderr).
|
|
|
+ * To quiet any output you have to replace the body of the example function
|
|
|
+ * with just "return;" and use it in the set function.
|
|
|
+ */
|
|
|
+int CDECL lame_set_errorf(lame_global_flags *, lame_report_function);
|
|
|
+int CDECL lame_set_debugf(lame_global_flags *, lame_report_function);
|
|
|
+int CDECL lame_set_msgf (lame_global_flags *, lame_report_function);
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/* set one of brate compression ratio. default is compression ratio of 11. */
|
|
|
+int CDECL lame_set_brate(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_brate(const lame_global_flags *);
|
|
|
+int CDECL lame_set_compression_ratio(lame_global_flags *, float);
|
|
|
+float CDECL lame_get_compression_ratio(const lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+int CDECL lame_set_preset( lame_global_flags* gfp, int );
|
|
|
+int CDECL lame_set_asm_optimizations( lame_global_flags* gfp, int, int );
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/********************************************************************
|
|
|
+ * frame params
|
|
|
+ ***********************************************************************/
|
|
|
+/* mark as copyright. default=0 */
|
|
|
+int CDECL lame_set_copyright(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_copyright(const lame_global_flags *);
|
|
|
+
|
|
|
+/* mark as original. default=1 */
|
|
|
+int CDECL lame_set_original(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_original(const lame_global_flags *);
|
|
|
+
|
|
|
+/* error_protection. Use 2 bytes from each frame for CRC checksum. default=0 */
|
|
|
+int CDECL lame_set_error_protection(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_error_protection(const lame_global_flags *);
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/* padding_type. 0=pad no frames 1=pad all frames 2=adjust padding(default) */
|
|
|
+int CDECL lame_set_padding_type(lame_global_flags *, Padding_type);
|
|
|
+Padding_type CDECL lame_get_padding_type(const lame_global_flags *);
|
|
|
+#endif
|
|
|
+
|
|
|
+/* MP3 'private extension' bit Meaningless. default=0 */
|
|
|
+int CDECL lame_set_extension(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_extension(const lame_global_flags *);
|
|
|
+
|
|
|
+/* enforce strict ISO compliance. default=0 */
|
|
|
+int CDECL lame_set_strict_ISO(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_strict_ISO(const lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+/********************************************************************
|
|
|
+ * quantization/noise shaping
|
|
|
+ ***********************************************************************/
|
|
|
+
|
|
|
+/* disable the bit reservoir. For testing only. default=0 */
|
|
|
+int CDECL lame_set_disable_reservoir(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_disable_reservoir(const lame_global_flags *);
|
|
|
+
|
|
|
+/* select a different "best quantization" function. default=0 */
|
|
|
+int CDECL lame_set_quant_comp(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_quant_comp(const lame_global_flags *);
|
|
|
+int CDECL lame_set_quant_comp_short(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_quant_comp_short(const lame_global_flags *);
|
|
|
+
|
|
|
+int CDECL lame_set_experimentalX(lame_global_flags *, int); /* compatibility*/
|
|
|
+int CDECL lame_get_experimentalX(const lame_global_flags *);
|
|
|
+
|
|
|
+/* another experimental option. for testing only */
|
|
|
+int CDECL lame_set_experimentalY(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_experimentalY(const lame_global_flags *);
|
|
|
+
|
|
|
+/* another experimental option. for testing only */
|
|
|
+int CDECL lame_set_experimentalZ(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_experimentalZ(const lame_global_flags *);
|
|
|
+
|
|
|
+/* Naoki's psycho acoustic model. default=0 */
|
|
|
+int CDECL lame_set_exp_nspsytune(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_exp_nspsytune(const lame_global_flags *);
|
|
|
+
|
|
|
+void CDECL lame_set_msfix(lame_global_flags *, double);
|
|
|
+float CDECL lame_get_msfix(const lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+/********************************************************************
|
|
|
+ * VBR control
|
|
|
+ ***********************************************************************/
|
|
|
+/* Types of VBR. default = vbr_off = CBR */
|
|
|
+int CDECL lame_set_VBR(lame_global_flags *, vbr_mode);
|
|
|
+vbr_mode CDECL lame_get_VBR(const lame_global_flags *);
|
|
|
+
|
|
|
+/* VBR quality level. 0=highest 9=lowest */
|
|
|
+int CDECL lame_set_VBR_q(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_VBR_q(const lame_global_flags *);
|
|
|
+
|
|
|
+/* VBR quality level. 0=highest 9=lowest, Range [0,...,10[ */
|
|
|
+int CDECL lame_set_VBR_quality(lame_global_flags *, float);
|
|
|
+float CDECL lame_get_VBR_quality(const lame_global_flags *);
|
|
|
+
|
|
|
+/* Ignored except for VBR=vbr_abr (ABR mode) */
|
|
|
+int CDECL lame_set_VBR_mean_bitrate_kbps(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_VBR_mean_bitrate_kbps(const lame_global_flags *);
|
|
|
+
|
|
|
+int CDECL lame_set_VBR_min_bitrate_kbps(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_VBR_min_bitrate_kbps(const lame_global_flags *);
|
|
|
+
|
|
|
+int CDECL lame_set_VBR_max_bitrate_kbps(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_VBR_max_bitrate_kbps(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ 1=strictly enforce VBR_min_bitrate. Normally it will be violated for
|
|
|
+ analog silence
|
|
|
+*/
|
|
|
+int CDECL lame_set_VBR_hard_min(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_VBR_hard_min(const lame_global_flags *);
|
|
|
+
|
|
|
+/* for preset */
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+int CDECL lame_set_preset_expopts(lame_global_flags *, int);
|
|
|
+#endif
|
|
|
+
|
|
|
+/********************************************************************
|
|
|
+ * Filtering control
|
|
|
+ ***********************************************************************/
|
|
|
+/* freq in Hz to apply lowpass. Default = 0 = lame chooses. -1 = disabled */
|
|
|
+int CDECL lame_set_lowpassfreq(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_lowpassfreq(const lame_global_flags *);
|
|
|
+/* width of transition band, in Hz. Default = one polyphase filter band */
|
|
|
+int CDECL lame_set_lowpasswidth(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_lowpasswidth(const lame_global_flags *);
|
|
|
+
|
|
|
+/* freq in Hz to apply highpass. Default = 0 = lame chooses. -1 = disabled */
|
|
|
+int CDECL lame_set_highpassfreq(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_highpassfreq(const lame_global_flags *);
|
|
|
+/* width of transition band, in Hz. Default = one polyphase filter band */
|
|
|
+int CDECL lame_set_highpasswidth(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_highpasswidth(const lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+/********************************************************************
|
|
|
+ * psycho acoustics and other arguments which you should not change
|
|
|
+ * unless you know what you are doing
|
|
|
+ ***********************************************************************/
|
|
|
+
|
|
|
+/* only use ATH for masking */
|
|
|
+int CDECL lame_set_ATHonly(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_ATHonly(const lame_global_flags *);
|
|
|
+
|
|
|
+/* only use ATH for short blocks */
|
|
|
+int CDECL lame_set_ATHshort(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_ATHshort(const lame_global_flags *);
|
|
|
+
|
|
|
+/* disable ATH */
|
|
|
+int CDECL lame_set_noATH(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_noATH(const lame_global_flags *);
|
|
|
+
|
|
|
+/* select ATH formula */
|
|
|
+int CDECL lame_set_ATHtype(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_ATHtype(const lame_global_flags *);
|
|
|
+
|
|
|
+/* lower ATH by this many db */
|
|
|
+int CDECL lame_set_ATHlower(lame_global_flags *, float);
|
|
|
+float CDECL lame_get_ATHlower(const lame_global_flags *);
|
|
|
+
|
|
|
+/* select ATH adaptive adjustment type */
|
|
|
+int CDECL lame_set_athaa_type( lame_global_flags *, int);
|
|
|
+int CDECL lame_get_athaa_type( const lame_global_flags *);
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/* select the loudness approximation used by the ATH adaptive auto-leveling */
|
|
|
+int CDECL lame_set_athaa_loudapprox( lame_global_flags *, int);
|
|
|
+int CDECL lame_get_athaa_loudapprox( const lame_global_flags *);
|
|
|
+#endif
|
|
|
+
|
|
|
+/* adjust (in dB) the point below which adaptive ATH level adjustment occurs */
|
|
|
+int CDECL lame_set_athaa_sensitivity( lame_global_flags *, float);
|
|
|
+float CDECL lame_get_athaa_sensitivity( const lame_global_flags* );
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/* OBSOLETE: predictability limit (ISO tonality formula) */
|
|
|
+int CDECL lame_set_cwlimit(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_cwlimit(const lame_global_flags *);
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ allow blocktypes to differ between channels?
|
|
|
+ default: 0 for jstereo, 1 for stereo
|
|
|
+*/
|
|
|
+int CDECL lame_set_allow_diff_short(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_allow_diff_short(const lame_global_flags *);
|
|
|
+
|
|
|
+/* use temporal masking effect (default = 1) */
|
|
|
+int CDECL lame_set_useTemporal(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_useTemporal(const lame_global_flags *);
|
|
|
+
|
|
|
+/* use temporal masking effect (default = 1) */
|
|
|
+int CDECL lame_set_interChRatio(lame_global_flags *, float);
|
|
|
+float CDECL lame_get_interChRatio(const lame_global_flags *);
|
|
|
+
|
|
|
+/* disable short blocks */
|
|
|
+int CDECL lame_set_no_short_blocks(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_no_short_blocks(const lame_global_flags *);
|
|
|
+
|
|
|
+/* force short blocks */
|
|
|
+int CDECL lame_set_force_short_blocks(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_force_short_blocks(const lame_global_flags *);
|
|
|
+
|
|
|
+/* Input PCM is emphased PCM (for instance from one of the rarely
|
|
|
+ emphased CDs), it is STRONGLY not recommended to use this, because
|
|
|
+ psycho does not take it into account, and last but not least many decoders
|
|
|
+ ignore these bits */
|
|
|
+int CDECL lame_set_emphasis(lame_global_flags *, int);
|
|
|
+int CDECL lame_get_emphasis(const lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/************************************************************************/
|
|
|
+/* 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) */
|
|
|
+int CDECL lame_get_version(const lame_global_flags *);
|
|
|
+
|
|
|
+/* encoder delay */
|
|
|
+int CDECL lame_get_encoder_delay(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ 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.
|
|
|
+*/
|
|
|
+int CDECL lame_get_encoder_padding(const lame_global_flags *);
|
|
|
+
|
|
|
+/* size of MPEG frame */
|
|
|
+int CDECL lame_get_framesize(const lame_global_flags *);
|
|
|
+
|
|
|
+/* number of PCM samples buffered, but not yet encoded to mp3 data. */
|
|
|
+int CDECL lame_get_mf_samples_to_encode( const lame_global_flags* gfp );
|
|
|
+
|
|
|
+/*
|
|
|
+ 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.
|
|
|
+*/
|
|
|
+int CDECL lame_get_size_mp3buffer( const lame_global_flags* gfp );
|
|
|
+
|
|
|
+/* number of frames encoded so far */
|
|
|
+int CDECL lame_get_frameNum(const lame_global_flags *);
|
|
|
+
|
|
|
+/*
|
|
|
+ lame's estimate of the total number of frames to be encoded
|
|
|
+ only valid if calling program set num_samples
|
|
|
+*/
|
|
|
+int CDECL lame_get_totalframes(const lame_global_flags *);
|
|
|
+
|
|
|
+/* RadioGain value. Multiplied by 10 and rounded to the nearest. */
|
|
|
+int CDECL lame_get_RadioGain(const lame_global_flags *);
|
|
|
+
|
|
|
+/* AudiophileGain value. Multipled by 10 and rounded to the nearest. */
|
|
|
+int CDECL lame_get_AudiophileGain(const lame_global_flags *);
|
|
|
+
|
|
|
+/* the peak sample */
|
|
|
+float CDECL lame_get_PeakSample(const lame_global_flags *);
|
|
|
+
|
|
|
+/* Gain change required for preventing clipping. The value is correct only if
|
|
|
+ peak sample searching was enabled. If negative then the waveform
|
|
|
+ already does not clip. The value is multiplied by 10 and rounded up. */
|
|
|
+int CDECL lame_get_noclipGainChange(const lame_global_flags *);
|
|
|
+
|
|
|
+/* user-specified scale factor required for preventing clipping. Value is
|
|
|
+ correct only if peak sample searching was enabled and no user-specified
|
|
|
+ scaling was performed. If negative then either the waveform already does
|
|
|
+ not clip or the value cannot be determined */
|
|
|
+float CDECL lame_get_noclipScale(const lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * REQUIRED:
|
|
|
+ * sets more internal configuration based on data provided above.
|
|
|
+ * returns -1 if something failed.
|
|
|
+ */
|
|
|
+int CDECL lame_init_params(lame_global_flags *);
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * OPTIONAL:
|
|
|
+ * get the version number, in a string. of the form:
|
|
|
+ * "3.63 (beta)" or just "3.63".
|
|
|
+ */
|
|
|
+const char* CDECL get_lame_version ( void );
|
|
|
+const char* CDECL get_lame_short_version ( void );
|
|
|
+const char* CDECL get_lame_very_short_version ( void );
|
|
|
+const char* CDECL get_psy_version ( void );
|
|
|
+const char* CDECL get_lame_url ( void );
|
|
|
+const char* CDECL get_lame_os_bitness ( void );
|
|
|
+
|
|
|
+/*
|
|
|
+ * OPTIONAL:
|
|
|
+ * get the version numbers in numerical form.
|
|
|
+ */
|
|
|
+typedef struct {
|
|
|
+ /* generic LAME version */
|
|
|
+ int major;
|
|
|
+ int minor;
|
|
|
+ int alpha; /* 0 if not an alpha version */
|
|
|
+ int beta; /* 0 if not a beta version */
|
|
|
+
|
|
|
+ /* version of the psy model */
|
|
|
+ int psy_major;
|
|
|
+ int psy_minor;
|
|
|
+ int psy_alpha; /* 0 if not an alpha version */
|
|
|
+ int psy_beta; /* 0 if not a beta version */
|
|
|
+
|
|
|
+ /* compile time features */
|
|
|
+ const char *features; /* Don't make assumptions about the contents! */
|
|
|
+} lame_version_t;
|
|
|
+void CDECL get_lame_version_numerical(lame_version_t *);
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * OPTIONAL:
|
|
|
+ * print internal lame configuration to message handler
|
|
|
+ */
|
|
|
+void CDECL lame_print_config(const lame_global_flags* gfp);
|
|
|
+
|
|
|
+void CDECL lame_print_internals( const lame_global_flags *gfp);
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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
|
|
|
+ *
|
|
|
+ * 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[].
|
|
|
+ *
|
|
|
+*/
|
|
|
+int CDECL lame_encode_buffer (
|
|
|
+ lame_global_flags* gfp, /* global context handle */
|
|
|
+ const short int buffer_l [], /* PCM data for left channel */
|
|
|
+ const short int buffer_r [], /* PCM data for right channel */
|
|
|
+ const int nsamples, /* number of samples per channel */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ const int mp3buf_size ); /* number of valid octets in this
|
|
|
+ stream */
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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[]
|
|
|
+ */
|
|
|
+int CDECL lame_encode_buffer_interleaved(
|
|
|
+ lame_global_flags* gfp, /* global context handlei */
|
|
|
+ short int pcm[], /* PCM data for left and right
|
|
|
+ channel, interleaved */
|
|
|
+ int num_samples, /* number of samples per channel,
|
|
|
+ _not_ number of samples in
|
|
|
+ pcm[] */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ int mp3buf_size ); /* number of valid octets in this
|
|
|
+ stream */
|
|
|
+
|
|
|
+
|
|
|
+/* as lame_encode_buffer, but for 'float's.
|
|
|
+ * !! NOTE: !! data must still be scaled to be in the same range as
|
|
|
+ * short int, +/- 32768
|
|
|
+ */
|
|
|
+int CDECL lame_encode_buffer_float(
|
|
|
+ lame_global_flags* gfp, /* global context handle */
|
|
|
+ const float pcm_l [], /* PCM data for left channel */
|
|
|
+ const float pcm_r [], /* PCM data for right channel */
|
|
|
+ const int nsamples, /* number of samples per channel */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ const int mp3buf_size ); /* number of valid octets in this
|
|
|
+ stream */
|
|
|
+
|
|
|
+/* as lame_encode_buffer, but for 'float's.
|
|
|
+ * !! NOTE: !! data must be scaled to +/- 1 full scale
|
|
|
+ */
|
|
|
+int CDECL lame_encode_buffer_ieee_float(
|
|
|
+ lame_t gfp,
|
|
|
+ const float pcm_l [], /* PCM data for left channel */
|
|
|
+ const float pcm_r [], /* PCM data for right channel */
|
|
|
+ const int nsamples,
|
|
|
+ unsigned char * mp3buf,
|
|
|
+ const int mp3buf_size);
|
|
|
+int CDECL lame_encode_buffer_interleaved_ieee_float(
|
|
|
+ lame_t gfp,
|
|
|
+ const float pcm[], /* PCM data for left and right
|
|
|
+ channel, interleaved */
|
|
|
+ const int nsamples,
|
|
|
+ unsigned char * mp3buf,
|
|
|
+ const int mp3buf_size);
|
|
|
+
|
|
|
+/* as lame_encode_buffer, but for 'double's.
|
|
|
+ * !! NOTE: !! data must be scaled to +/- 1 full scale
|
|
|
+ */
|
|
|
+int CDECL lame_encode_buffer_ieee_double(
|
|
|
+ lame_t gfp,
|
|
|
+ const double pcm_l [], /* PCM data for left channel */
|
|
|
+ const double pcm_r [], /* PCM data for right channel */
|
|
|
+ const int nsamples,
|
|
|
+ unsigned char * mp3buf,
|
|
|
+ const int mp3buf_size);
|
|
|
+int CDECL lame_encode_buffer_interleaved_ieee_double(
|
|
|
+ lame_t gfp,
|
|
|
+ const double pcm[], /* PCM data for left and right
|
|
|
+ channel, interleaved */
|
|
|
+ const int nsamples,
|
|
|
+ unsigned char * mp3buf,
|
|
|
+ const int mp3buf_size);
|
|
|
+
|
|
|
+/* as lame_encode_buffer, but for long's
|
|
|
+ * !! NOTE: !! data must still be scaled to be in the same range as
|
|
|
+ * short int, +/- 32768
|
|
|
+ *
|
|
|
+ * This scaling was a mistake (doesn't allow one to exploit full
|
|
|
+ * precision of type 'long'. Use lame_encode_buffer_long2() instead.
|
|
|
+ *
|
|
|
+ */
|
|
|
+int CDECL lame_encode_buffer_long(
|
|
|
+ lame_global_flags* gfp, /* global context handle */
|
|
|
+ const long buffer_l [], /* PCM data for left channel */
|
|
|
+ const long buffer_r [], /* PCM data for right channel */
|
|
|
+ const int nsamples, /* number of samples per channel */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ const int mp3buf_size ); /* number of valid octets in this
|
|
|
+ stream */
|
|
|
+
|
|
|
+/* Same as lame_encode_buffer_long(), but with correct scaling.
|
|
|
+ * !! NOTE: !! data must still be scaled to be in the same range as
|
|
|
+ * type 'long'. Data should be in the range: +/- 2^(8*size(long)-1)
|
|
|
+ *
|
|
|
+ */
|
|
|
+int CDECL lame_encode_buffer_long2(
|
|
|
+ lame_global_flags* gfp, /* global context handle */
|
|
|
+ const long buffer_l [], /* PCM data for left channel */
|
|
|
+ const long buffer_r [], /* PCM data for right channel */
|
|
|
+ const int nsamples, /* number of samples per channel */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ const int mp3buf_size ); /* number of valid octets in this
|
|
|
+ stream */
|
|
|
+
|
|
|
+/* as lame_encode_buffer, but for int's
|
|
|
+ * !! NOTE: !! input should be scaled to the maximum range of 'int'
|
|
|
+ * If int is 4 bytes, then the values should range from
|
|
|
+ * +/- 2147483648.
|
|
|
+ *
|
|
|
+ * This routine does not (and cannot, without loosing precision) use
|
|
|
+ * the same scaling as the rest of the lame_encode_buffer() routines.
|
|
|
+ *
|
|
|
+ */
|
|
|
+int CDECL lame_encode_buffer_int(
|
|
|
+ lame_global_flags* gfp, /* global context handle */
|
|
|
+ const int buffer_l [], /* PCM data for left channel */
|
|
|
+ const int buffer_r [], /* PCM data for right channel */
|
|
|
+ const int nsamples, /* number of samples per channel */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ const int mp3buf_size ); /* number of valid octets in this
|
|
|
+ stream */
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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
|
|
|
+ */
|
|
|
+int CDECL lame_encode_flush(
|
|
|
+ lame_global_flags * gfp, /* global context handle */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ int size); /* number of valid octets in this stream */
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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
|
|
|
+ */
|
|
|
+int CDECL lame_encode_flush_nogap(
|
|
|
+ lame_global_flags * gfp, /* global context handle */
|
|
|
+ unsigned char* mp3buf, /* pointer to encoded MP3 stream */
|
|
|
+ int size); /* number of valid octets in this stream */
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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().
|
|
|
+ */
|
|
|
+int CDECL lame_init_bitstream(
|
|
|
+ lame_global_flags * gfp); /* global context handle */
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ * OPTIONAL: some simple statistics
|
|
|
+ * a bitrate histogram to visualize the distribution of used frame sizes
|
|
|
+ * a stereo mode histogram to visualize the distribution of used stereo
|
|
|
+ * modes, useful in joint-stereo mode only
|
|
|
+ * 0: LR left-right encoded
|
|
|
+ * 1: LR-I left-right and intensity encoded (currently not supported)
|
|
|
+ * 2: MS mid-side encoded
|
|
|
+ * 3: MS-I mid-side and intensity encoded (currently not supported)
|
|
|
+ *
|
|
|
+ * attention: don't call them after lame_encode_finish
|
|
|
+ * suggested: lame_encode_flush -> lame_*_hist -> lame_close
|
|
|
+ */
|
|
|
+
|
|
|
+void CDECL lame_bitrate_hist(
|
|
|
+ const lame_global_flags * gfp,
|
|
|
+ int bitrate_count[14] );
|
|
|
+void CDECL lame_bitrate_kbps(
|
|
|
+ const lame_global_flags * gfp,
|
|
|
+ int bitrate_kbps [14] );
|
|
|
+void CDECL lame_stereo_mode_hist(
|
|
|
+ const lame_global_flags * gfp,
|
|
|
+ int stereo_mode_count[4] );
|
|
|
+
|
|
|
+void CDECL lame_bitrate_stereo_mode_hist (
|
|
|
+ const lame_global_flags * gfp,
|
|
|
+ int bitrate_stmode_count[14][4] );
|
|
|
+
|
|
|
+void CDECL lame_block_type_hist (
|
|
|
+ const lame_global_flags * gfp,
|
|
|
+ int btype_count[6] );
|
|
|
+
|
|
|
+void CDECL lame_bitrate_block_type_hist (
|
|
|
+ const lame_global_flags * gfp,
|
|
|
+ int bitrate_btype_count[14][6] );
|
|
|
+
|
|
|
+#if (DEPRECATED_OR_OBSOLETE_CODE_REMOVED && 0)
|
|
|
+#else
|
|
|
+/*
|
|
|
+ * OPTIONAL:
|
|
|
+ * lame_mp3_tags_fid will rewrite a Xing VBR tag to the mp3 file with file
|
|
|
+ * pointer fid. These calls perform forward and backwards seeks, so make
|
|
|
+ * sure fid is a real file. Make sure lame_encode_flush has been called,
|
|
|
+ * and all mp3 data has been written to the file before calling this
|
|
|
+ * function.
|
|
|
+ * NOTE:
|
|
|
+ * if VBR tags are turned off by the user, or turned off by LAME because
|
|
|
+ * the output is not a regular file, this call does nothing
|
|
|
+ * NOTE:
|
|
|
+ * LAME wants to read from the file to skip an optional ID3v2 tag, so
|
|
|
+ * make sure you opened the file for writing and reading.
|
|
|
+ * NOTE:
|
|
|
+ * You can call lame_get_lametag_frame instead, if you want to insert
|
|
|
+ * the lametag yourself.
|
|
|
+*/
|
|
|
+void CDECL lame_mp3_tags_fid(lame_global_flags *, FILE* fid);
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ * OPTIONAL:
|
|
|
+ * lame_get_lametag_frame copies the final LAME-tag into 'buffer'.
|
|
|
+ * The function returns the number of bytes copied into buffer, or
|
|
|
+ * the required buffer size, if the provided buffer is too small.
|
|
|
+ * Function failed, if the return value is larger than 'size'!
|
|
|
+ * Make sure lame_encode flush has been called before calling this function.
|
|
|
+ * NOTE:
|
|
|
+ * if VBR tags are turned off by the user, or turned off by LAME,
|
|
|
+ * this call does nothing and returns 0.
|
|
|
+ * NOTE:
|
|
|
+ * LAME inserted an empty frame in the beginning of mp3 audio data,
|
|
|
+ * which you have to replace by the final LAME-tag frame after encoding.
|
|
|
+ * In case there is no ID3v2 tag, usually this frame will be the very first
|
|
|
+ * data in your mp3 file. If you put some other leading data into your
|
|
|
+ * file, you'll have to do some bookkeeping about where to write this buffer.
|
|
|
+ */
|
|
|
+size_t CDECL lame_get_lametag_frame(
|
|
|
+ const lame_global_flags *, unsigned char* buffer, size_t size);
|
|
|
+
|
|
|
+/*
|
|
|
+ * REQUIRED:
|
|
|
+ * final call to free all remaining buffers
|
|
|
+ */
|
|
|
+int CDECL lame_close (lame_global_flags *);
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/*
|
|
|
+ * OBSOLETE:
|
|
|
+ * lame_encode_finish combines lame_encode_flush() and lame_close() in
|
|
|
+ * one call. However, once this call is made, the statistics routines
|
|
|
+ * will no longer work because the data will have been cleared, and
|
|
|
+ * lame_mp3_tags_fid() cannot be called to add data to the VBR header
|
|
|
+ */
|
|
|
+int CDECL lame_encode_finish(
|
|
|
+ lame_global_flags* gfp,
|
|
|
+ unsigned char* mp3buf,
|
|
|
+ int size );
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/*********************************************************************
|
|
|
+ *
|
|
|
+ * decoding
|
|
|
+ *
|
|
|
+ * a simple interface to mpglib, part of mpg123, is also included if
|
|
|
+ * libmp3lame is compiled with HAVE_MPGLIB
|
|
|
+ *
|
|
|
+ *********************************************************************/
|
|
|
+
|
|
|
+struct hip_global_struct;
|
|
|
+typedef struct hip_global_struct hip_global_flags;
|
|
|
+typedef hip_global_flags *hip_t;
|
|
|
+
|
|
|
+
|
|
|
+typedef struct {
|
|
|
+ int header_parsed; /* 1 if header was parsed and following data was
|
|
|
+ computed */
|
|
|
+ int stereo; /* number of channels */
|
|
|
+ int samplerate; /* sample rate */
|
|
|
+ int bitrate; /* bitrate */
|
|
|
+ int mode; /* mp3 frame type */
|
|
|
+ int mode_ext; /* mp3 frame type */
|
|
|
+ int framesize; /* number of samples per mp3 frame */
|
|
|
+
|
|
|
+ /* this data is only computed if mpglib detects a Xing VBR header */
|
|
|
+ unsigned long nsamp; /* number of samples in mp3 file. */
|
|
|
+ int totalframes; /* total number of frames in mp3 file */
|
|
|
+
|
|
|
+ /* this data is not currently computed by the mpglib routines */
|
|
|
+ int framenum; /* frames decoded counter */
|
|
|
+} mp3data_struct;
|
|
|
+
|
|
|
+/* required call to initialize decoder */
|
|
|
+hip_t CDECL hip_decode_init(void);
|
|
|
+
|
|
|
+/* cleanup call to exit decoder */
|
|
|
+int CDECL hip_decode_exit(hip_t gfp);
|
|
|
+
|
|
|
+/* HIP reporting functions */
|
|
|
+void CDECL hip_set_errorf(hip_t gfp, lame_report_function f);
|
|
|
+void CDECL hip_set_debugf(hip_t gfp, lame_report_function f);
|
|
|
+void CDECL hip_set_msgf (hip_t gfp, lame_report_function f);
|
|
|
+
|
|
|
+/*********************************************************************
|
|
|
+ * input 1 mp3 frame, output (maybe) pcm data.
|
|
|
+ *
|
|
|
+ * nout = hip_decode(hip, mp3buf,len,pcm_l,pcm_r);
|
|
|
+ *
|
|
|
+ * input:
|
|
|
+ * len : number of bytes of mp3 data in mp3buf
|
|
|
+ * mp3buf[len] : mp3 data to be decoded
|
|
|
+ *
|
|
|
+ * output:
|
|
|
+ * nout: -1 : decoding error
|
|
|
+ * 0 : need more data before we can complete the decode
|
|
|
+ * >0 : returned 'nout' samples worth of data in pcm_l,pcm_r
|
|
|
+ * pcm_l[nout] : left channel data
|
|
|
+ * pcm_r[nout] : right channel data
|
|
|
+ *
|
|
|
+ *********************************************************************/
|
|
|
+int CDECL hip_decode( hip_t gfp
|
|
|
+ , unsigned char * mp3buf
|
|
|
+ , size_t len
|
|
|
+ , short pcm_l[]
|
|
|
+ , short pcm_r[]
|
|
|
+ );
|
|
|
+
|
|
|
+/* same as hip_decode, and also returns mp3 header data */
|
|
|
+int CDECL hip_decode_headers( hip_t gfp
|
|
|
+ , unsigned char* mp3buf
|
|
|
+ , size_t len
|
|
|
+ , short pcm_l[]
|
|
|
+ , short pcm_r[]
|
|
|
+ , mp3data_struct* mp3data
|
|
|
+ );
|
|
|
+
|
|
|
+/* same as hip_decode, but returns at most one frame */
|
|
|
+int CDECL hip_decode1( hip_t gfp
|
|
|
+ , unsigned char* mp3buf
|
|
|
+ , size_t len
|
|
|
+ , short pcm_l[]
|
|
|
+ , short pcm_r[]
|
|
|
+ );
|
|
|
+
|
|
|
+/* same as hip_decode1, but returns at most one frame and mp3 header data */
|
|
|
+int CDECL hip_decode1_headers( hip_t gfp
|
|
|
+ , unsigned char* mp3buf
|
|
|
+ , size_t len
|
|
|
+ , short pcm_l[]
|
|
|
+ , short pcm_r[]
|
|
|
+ , mp3data_struct* mp3data
|
|
|
+ );
|
|
|
+
|
|
|
+/* same as hip_decode1_headers, but also returns enc_delay and enc_padding
|
|
|
+ from VBR Info tag, (-1 if no info tag was found) */
|
|
|
+int CDECL hip_decode1_headersB( hip_t gfp
|
|
|
+ , unsigned char* mp3buf
|
|
|
+ , size_t len
|
|
|
+ , short pcm_l[]
|
|
|
+ , short pcm_r[]
|
|
|
+ , mp3data_struct* mp3data
|
|
|
+ , int *enc_delay
|
|
|
+ , int *enc_padding
|
|
|
+ );
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/* OBSOLETE:
|
|
|
+ * lame_decode... functions are there to keep old code working
|
|
|
+ * but it is strongly recommended to replace calls by hip_decode...
|
|
|
+ * function calls, see above.
|
|
|
+ */
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+int CDECL lame_decode_init(void);
|
|
|
+int CDECL lame_decode(
|
|
|
+ unsigned char * mp3buf,
|
|
|
+ int len,
|
|
|
+ short pcm_l[],
|
|
|
+ short pcm_r[] );
|
|
|
+int CDECL lame_decode_headers(
|
|
|
+ unsigned char* mp3buf,
|
|
|
+ int len,
|
|
|
+ short pcm_l[],
|
|
|
+ short pcm_r[],
|
|
|
+ mp3data_struct* mp3data );
|
|
|
+int CDECL lame_decode1(
|
|
|
+ unsigned char* mp3buf,
|
|
|
+ int len,
|
|
|
+ short pcm_l[],
|
|
|
+ short pcm_r[] );
|
|
|
+int CDECL lame_decode1_headers(
|
|
|
+ unsigned char* mp3buf,
|
|
|
+ int len,
|
|
|
+ short pcm_l[],
|
|
|
+ short pcm_r[],
|
|
|
+ mp3data_struct* mp3data );
|
|
|
+int CDECL lame_decode1_headersB(
|
|
|
+ unsigned char* mp3buf,
|
|
|
+ int len,
|
|
|
+ short pcm_l[],
|
|
|
+ short pcm_r[],
|
|
|
+ mp3data_struct* mp3data,
|
|
|
+ int *enc_delay,
|
|
|
+ int *enc_padding );
|
|
|
+int CDECL lame_decode_exit(void);
|
|
|
+
|
|
|
+#endif /* obsolete lame_decode API calls */
|
|
|
+
|
|
|
+
|
|
|
+/*********************************************************************
|
|
|
+ *
|
|
|
+ * id3tag stuff
|
|
|
+ *
|
|
|
+ *********************************************************************/
|
|
|
+
|
|
|
+/*
|
|
|
+ * id3tag.h -- Interface to write ID3 version 1 and 2 tags.
|
|
|
+ *
|
|
|
+ * Copyright (C) 2000 Don Melton.
|
|
|
+ *
|
|
|
+ * This library is free software; you can redistribute it and/or
|
|
|
+ * modify it under the terms of the GNU Library General Public
|
|
|
+ * License as published by the Free Software Foundation; either
|
|
|
+ * version 2 of the License, or (at your option) any later version.
|
|
|
+ *
|
|
|
+ * This library is distributed in the hope that it will be useful,
|
|
|
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
+ * Library General Public License for more details.
|
|
|
+ *
|
|
|
+ * You should have received a copy of the GNU Library General Public
|
|
|
+ * License along with this library; if not, write to the Free Software
|
|
|
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
|
|
|
+ */
|
|
|
+
|
|
|
+/* utility to obtain alphabetically sorted list of genre names with numbers */
|
|
|
+void CDECL id3tag_genre_list(
|
|
|
+ void (*handler)(int, const char *, void *),
|
|
|
+ void* cookie);
|
|
|
+
|
|
|
+void CDECL id3tag_init (lame_t gfp);
|
|
|
+
|
|
|
+/* force addition of version 2 tag */
|
|
|
+void CDECL id3tag_add_v2 (lame_t gfp);
|
|
|
+
|
|
|
+/* add only a version 1 tag */
|
|
|
+void CDECL id3tag_v1_only (lame_t gfp);
|
|
|
+
|
|
|
+/* add only a version 2 tag */
|
|
|
+void CDECL id3tag_v2_only (lame_t gfp);
|
|
|
+
|
|
|
+/* pad version 1 tag with spaces instead of nulls */
|
|
|
+void CDECL id3tag_space_v1 (lame_t gfp);
|
|
|
+
|
|
|
+/* pad version 2 tag with extra 128 bytes */
|
|
|
+void CDECL id3tag_pad_v2 (lame_t gfp);
|
|
|
+
|
|
|
+/* pad version 2 tag with extra n bytes */
|
|
|
+void CDECL id3tag_set_pad (lame_t gfp, size_t n);
|
|
|
+
|
|
|
+void CDECL id3tag_set_title(lame_t gfp, const char* title);
|
|
|
+void CDECL id3tag_set_artist(lame_t gfp, const char* artist);
|
|
|
+void CDECL id3tag_set_album(lame_t gfp, const char* album);
|
|
|
+void CDECL id3tag_set_year(lame_t gfp, const char* year);
|
|
|
+void CDECL id3tag_set_comment(lame_t gfp, const char* comment);
|
|
|
+
|
|
|
+/* return -1 result if track number is out of ID3v1 range
|
|
|
+ and ignored for ID3v1 */
|
|
|
+int CDECL id3tag_set_track(lame_t gfp, const char* track);
|
|
|
+
|
|
|
+/* return non-zero result if genre name or number is invalid
|
|
|
+ result 0: OK
|
|
|
+ result -1: genre number out of range
|
|
|
+ result -2: no valid ID3v1 genre name, mapped to ID3v1 'Other'
|
|
|
+ but taken as-is for ID3v2 genre tag */
|
|
|
+int CDECL id3tag_set_genre(lame_t gfp, const char* genre);
|
|
|
+
|
|
|
+/* return non-zero result if field name is invalid */
|
|
|
+int CDECL id3tag_set_fieldvalue(lame_t gfp, const char* fieldvalue);
|
|
|
+
|
|
|
+/* return non-zero result if image type is invalid */
|
|
|
+int CDECL id3tag_set_albumart(lame_t gfp, const char* image, size_t size);
|
|
|
+
|
|
|
+/* lame_get_id3v1_tag copies ID3v1 tag into buffer.
|
|
|
+ * Function returns number of bytes copied into buffer, or number
|
|
|
+ * of bytes rquired if buffer 'size' is too small.
|
|
|
+ * Function fails, if returned value is larger than 'size'.
|
|
|
+ * NOTE:
|
|
|
+ * This functions does nothing, if user/LAME disabled ID3v1 tag.
|
|
|
+ */
|
|
|
+size_t CDECL lame_get_id3v1_tag(lame_t gfp, unsigned char* buffer, size_t size);
|
|
|
+
|
|
|
+/* lame_get_id3v2_tag copies ID3v2 tag into buffer.
|
|
|
+ * Function returns number of bytes copied into buffer, or number
|
|
|
+ * of bytes rquired if buffer 'size' is too small.
|
|
|
+ * Function fails, if returned value is larger than 'size'.
|
|
|
+ * NOTE:
|
|
|
+ * This functions does nothing, if user/LAME disabled ID3v2 tag.
|
|
|
+ */
|
|
|
+size_t CDECL lame_get_id3v2_tag(lame_t gfp, unsigned char* buffer, size_t size);
|
|
|
+
|
|
|
+/* normaly lame_init_param writes ID3v2 tags into the audio stream
|
|
|
+ * Call lame_set_write_id3tag_automatic(gfp, 0) before lame_init_param
|
|
|
+ * to turn off this behaviour and get ID3v2 tag with above function
|
|
|
+ * write it yourself into your file.
|
|
|
+ */
|
|
|
+void CDECL lame_set_write_id3tag_automatic(lame_global_flags * gfp, int);
|
|
|
+int CDECL lame_get_write_id3tag_automatic(lame_global_flags const* gfp);
|
|
|
+
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_textinfo_latin1(lame_t gfp, char const *id, char const *text);
|
|
|
+
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_comment_latin1(lame_t gfp, char const *lang, char const *desc, char const *text);
|
|
|
+
|
|
|
+#if DEPRECATED_OR_OBSOLETE_CODE_REMOVED
|
|
|
+#else
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_textinfo_ucs2(lame_t gfp, char const *id, unsigned short const *text);
|
|
|
+
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_comment_ucs2(lame_t gfp, char const *lang,
|
|
|
+ unsigned short const *desc, unsigned short const *text);
|
|
|
+
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_fieldvalue_ucs2(lame_t gfp, const unsigned short *fieldvalue);
|
|
|
+#endif
|
|
|
+
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_fieldvalue_utf16(lame_t gfp, const unsigned short *fieldvalue);
|
|
|
+
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_textinfo_utf16(lame_t gfp, char const *id, unsigned short const *text);
|
|
|
+
|
|
|
+/* experimental */
|
|
|
+int CDECL id3tag_set_comment_utf16(lame_t gfp, char const *lang, unsigned short const *desc, unsigned short const *text);
|
|
|
+
|
|
|
+
|
|
|
+/***********************************************************************
|
|
|
+*
|
|
|
+* list of valid bitrates [kbps] & sample frequencies [Hz].
|
|
|
+* first index: 0: MPEG-2 values (sample frequencies 16...24 kHz)
|
|
|
+* 1: MPEG-1 values (sample frequencies 32...48 kHz)
|
|
|
+* 2: MPEG-2.5 values (sample frequencies 8...12 kHz)
|
|
|
+***********************************************************************/
|
|
|
+
|
|
|
+extern const int bitrate_table [3][16];
|
|
|
+extern const int samplerate_table [3][ 4];
|
|
|
+
|
|
|
+/* access functions for use in DLL, global vars are not exported */
|
|
|
+int CDECL lame_get_bitrate(int mpeg_version, int table_index);
|
|
|
+int CDECL lame_get_samplerate(int mpeg_version, int table_index);
|
|
|
+
|
|
|
+
|
|
|
+/* maximum size of albumart image (128KB), which affects LAME_MAXMP3BUFFER
|
|
|
+ as well since lame_encode_buffer() also returns ID3v2 tag data */
|
|
|
+#define LAME_MAXALBUMART (128 * 1024)
|
|
|
+
|
|
|
+/* 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) */
|
|
|
+#define LAME_MAXMP3BUFFER (16384 + LAME_MAXALBUMART)
|
|
|
+
|
|
|
+
|
|
|
+typedef enum {
|
|
|
+ LAME_OKAY = 0,
|
|
|
+ LAME_NOERROR = 0,
|
|
|
+ LAME_GENERICERROR = -1,
|
|
|
+ LAME_NOMEM = -10,
|
|
|
+ LAME_BADBITRATE = -11,
|
|
|
+ LAME_BADSAMPFREQ = -12,
|
|
|
+ LAME_INTERNALERROR = -13,
|
|
|
+
|
|
|
+ FRONTEND_READERROR = -80,
|
|
|
+ FRONTEND_WRITEERROR = -81,
|
|
|
+ FRONTEND_FILETOOLARGE = -82
|
|
|
+
|
|
|
+} lame_errorcodes_t;
|
|
|
+
|
|
|
+#if defined(__cplusplus)
|
|
|
+}
|
|
|
+#endif
|
|
|
+#endif /* LAME_LAME_H */
|
|
|
+
|
fancy
