home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / lame / lame.h
Encoding:
C/C++ Source or Header  |  2007-04-10  |  39.6 KB  |  1,111 lines
  1. /*
  2.  *    Interface to MP3 LAME encoding engine
  3.  *
  4.  *    Copyright (c) 1999 Mark Taylor
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2, or (at your option)
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; see the file COPYING.  If not, write to
  18.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. /* $Id: lame.h,v 1.154 2004/04/11 15:39:53 glessard Exp $ */
  22.  
  23. #ifndef LAME_LAME_H
  24. #define LAME_LAME_H
  25.  
  26. #include <stdio.h>
  27. #include <stdarg.h>
  28.  
  29. #if defined(__cplusplus)
  30. extern "C" {
  31. #endif
  32.  
  33. #if defined(WIN32)
  34. #undef CDECL
  35. #define CDECL _cdecl
  36. #else
  37. #define CDECL
  38. #endif
  39.  
  40.  
  41. typedef enum vbr_mode_e {
  42.   vbr_off=0,
  43.   vbr_mt,               /* obsolete, same as vbr_mtrh */
  44.   vbr_rh,
  45.   vbr_abr,
  46.   vbr_mtrh,
  47.   vbr_max_indicator,    /* Don't use this! It's used for sanity checks.       */
  48.   vbr_default=vbr_rh    /* change this to change the default VBR mode of LAME */
  49. } vbr_mode;
  50.  
  51.  
  52. /* MPEG modes */
  53. typedef enum MPEG_mode_e {
  54.   STEREO = 0,
  55.   JOINT_STEREO,
  56.   DUAL_CHANNEL,   /* LAME doesn't supports this! */
  57.   MONO,
  58.   NOT_SET,
  59.   MAX_INDICATOR   /* Don't use this! It's used for sanity checks. */ 
  60. } MPEG_mode;
  61.  
  62. /* Padding types */
  63. typedef enum Padding_type_e {
  64.   PAD_NO = 0,
  65.   PAD_ALL,
  66.   PAD_ADJUST,
  67.   PAD_MAX_INDICATOR   /* Don't use this! It's used for sanity checks. */
  68. } Padding_type;
  69.  
  70.  
  71.  
  72. /*presets*/
  73. typedef enum preset_mode_e {
  74.     /*values from 8 to 320 should be reserved for abr bitrates*/
  75.     /*for abr I'd suggest to directly use the targeted bitrate as a value*/
  76.     ABR_8 = 8,
  77.     ABR_320 = 320,
  78.  
  79.     V9 = 410, /*Vx to match Lame and VBR_xx to match FhG*/
  80.     VBR_10 = 410,
  81.     V8 = 420,
  82.     VBR_20 = 420,
  83.     V7 = 430,
  84.     VBR_30 = 430,
  85.     V6 = 440,
  86.     VBR_40 = 440,
  87.     V5 = 450,
  88.     VBR_50 = 450,
  89.     V4 = 460,
  90.     VBR_60 = 460,
  91.     V3 = 470,
  92.     VBR_70 = 470,
  93.     V2 = 480,
  94.     VBR_80 = 480,
  95.     V1 = 490,
  96.     VBR_90 = 490,
  97.     V0 = 500,
  98.     VBR_100 = 500,
  99.  
  100.  
  101.  
  102.     /*still there for compatibility*/
  103.     R3MIX = 1000,
  104.     STANDARD = 1001,
  105.     EXTREME = 1002,
  106.     INSANE = 1003,
  107.     STANDARD_FAST = 1004,
  108.     EXTREME_FAST = 1005,
  109.     MEDIUM = 1006,
  110.     MEDIUM_FAST = 1007
  111. } preset_mode;
  112.  
  113.  
  114. /*asm optimizations*/
  115. typedef enum asm_optimizations_e {
  116.     MMX = 1,
  117.     AMD_3DNOW = 2,
  118.     SSE = 3
  119. } asm_optimizations;
  120.  
  121.  
  122. /* psychoacoustic model */
  123. typedef enum Psy_model_e {
  124.     PSY_GPSYCHO = 1,
  125.     PSY_NSPSYTUNE = 2
  126. } Psy_model;
  127.  
  128.  
  129. struct lame_global_struct;
  130. typedef struct lame_global_struct lame_global_flags;
  131. typedef lame_global_flags *lame_t;
  132.  
  133.  
  134.  
  135.  
  136. /***********************************************************************
  137.  *
  138.  *  The LAME API
  139.  *  These functions should be called, in this order, for each
  140.  *  MP3 file to be encoded.  See the file "API" for more documentation 
  141.  *
  142.  ***********************************************************************/
  143.  
  144.  
  145. /*
  146.  * REQUIRED:
  147.  * initialize the encoder.  sets default for all encoder parameters,
  148.  * returns NULL if some malloc()'s failed
  149.  * otherwise returns pointer to structure needed for all future
  150.  * API calls.
  151.  */
  152. lame_global_flags * CDECL lame_init(void);
  153. /* obsolete version */
  154. int CDECL lame_init_old(lame_global_flags *);
  155.  
  156.  
  157. /*
  158.  * OPTIONAL:
  159.  * set as needed to override defaults
  160.  */
  161.  
  162. /********************************************************************
  163.  *  input stream description
  164.  ***********************************************************************/
  165. /* number of samples.  default = 2^32-1   */
  166. int CDECL lame_set_num_samples(lame_global_flags *, unsigned long);
  167. unsigned long CDECL lame_get_num_samples(const lame_global_flags *);
  168.  
  169. /* input sample rate in Hz.  default = 44100hz */
  170. int CDECL lame_set_in_samplerate(lame_global_flags *, int);
  171. int CDECL lame_get_in_samplerate(const lame_global_flags *);
  172.  
  173. /* number of channels in input stream. default=2  */
  174. int CDECL lame_set_num_channels(lame_global_flags *, int);
  175. int CDECL lame_get_num_channels(const lame_global_flags *);
  176.  
  177. /*
  178.   scale the input by this amount before encoding.  default=0 (disabled)
  179.   (not used by decoding routines)
  180. */
  181. int CDECL lame_set_scale(lame_global_flags *, float);
  182. float CDECL lame_get_scale(const lame_global_flags *);
  183.     
  184. /*
  185.   scale the channel 0 (left) input by this amount before encoding.
  186.     default=0 (disabled)
  187.   (not used by decoding routines)
  188. */
  189. int CDECL lame_set_scale_left(lame_global_flags *, float);
  190. float CDECL lame_get_scale_left(const lame_global_flags *);
  191.  
  192. /*
  193.   scale the channel 1 (right) input by this amount before encoding.
  194.     default=0 (disabled)
  195.   (not used by decoding routines)
  196. */
  197. int CDECL lame_set_scale_right(lame_global_flags *, float);
  198. float CDECL lame_get_scale_right(const lame_global_flags *);
  199.  
  200. /*
  201.   output sample rate in Hz.  default = 0, which means LAME picks best value
  202.   based on the amount of compression.  MPEG only allows:
  203.   MPEG1    32, 44.1,   48khz
  204.   MPEG2    16, 22.05,  24
  205.   MPEG2.5   8, 11.025, 12
  206.   (not used by decoding routines)
  207. */
  208. int CDECL lame_set_out_samplerate(lame_global_flags *, int);
  209. int CDECL lame_get_out_samplerate(const lame_global_flags *);
  210.  
  211.  
  212. /********************************************************************
  213.  *  general control parameters
  214.  ***********************************************************************/
  215. /* 1=cause LAME to collect data for an MP3 frame analyzer. default=0 */
  216. int CDECL lame_set_analysis(lame_global_flags *, int);
  217. int CDECL lame_get_analysis(const lame_global_flags *);
  218.  
  219. /*
  220.   1 = write a Xing VBR header frame.
  221.   default = 1
  222.   this variable must have been added by a Hungarian notation Windows programmer :-)
  223. */
  224. int CDECL lame_set_bWriteVbrTag(lame_global_flags *, int);
  225. int CDECL lame_get_bWriteVbrTag(const lame_global_flags *);
  226.  
  227. /* 1=decode only.  use lame/mpglib to convert mp3/ogg to wav.  default=0 */
  228. int CDECL lame_set_decode_only(lame_global_flags *, int);
  229. int CDECL lame_get_decode_only(const lame_global_flags *);
  230.  
  231. /* 1=encode a Vorbis .ogg file.  default=0 */
  232. /* DEPRECATED */
  233. int CDECL lame_set_ogg(lame_global_flags *, int);
  234. int CDECL lame_get_ogg(const lame_global_flags *);
  235.  
  236. /*
  237.   internal algorithm selection.  True quality is determined by the bitrate
  238.   but this variable will effect quality by selecting expensive or cheap algorithms.
  239.   quality=0..9.  0=best (very slow).  9=worst.
  240.   recommended:  2     near-best quality, not too slow
  241.                 5     good quality, fast
  242.                 7     ok quality, really fast
  243. */
  244. int CDECL lame_set_quality(lame_global_flags *, int);
  245. int CDECL lame_get_quality(const lame_global_flags *);
  246.  
  247. /*
  248.   mode = 0,1,2,3 = stereo, jstereo, dual channel (not supported), mono
  249.   default: lame picks based on compression ration and input channels
  250. */
  251. int CDECL lame_set_mode(lame_global_flags *, MPEG_mode);
  252. MPEG_mode CDECL lame_get_mode(const lame_global_flags *);
  253.  
  254. /*
  255.   mode_automs.  Use a M/S mode with a switching threshold based on
  256.   compression ratio
  257.   DEPRECATED
  258. */
  259. int CDECL lame_set_mode_automs(lame_global_flags *, int);
  260. int CDECL lame_get_mode_automs(const lame_global_flags *);
  261.  
  262. /*
  263.   force_ms.  Force M/S for all frames.  For testing only.
  264.   default = 0 (disabled)
  265. */
  266. int CDECL lame_set_force_ms(lame_global_flags *, int);
  267. int CDECL lame_get_force_ms(const lame_global_flags *);
  268.  
  269. /* use free_format?  default = 0 (disabled) */
  270. int CDECL lame_set_free_format(lame_global_flags *, int);
  271. int CDECL lame_get_free_format(const lame_global_flags *);
  272.  
  273. /* perform ReplayGain analysis?  default = 0 (disabled) */
  274. int CDECL lame_set_findReplayGain(lame_global_flags *, int);
  275. int CDECL lame_get_findReplayGain(const lame_global_flags *);
  276.  
  277. /* decode on the fly. Search for the peak sample. If the ReplayGain
  278.  * analysis is enabled then perform the analysis on the decoded data
  279.  * stream. default = 0 (disabled) 
  280.  * NOTE: if this option is set the build-in decoder should not be used */
  281. int CDECL lame_set_decode_on_the_fly(lame_global_flags *, int);
  282. int CDECL lame_get_decode_on_the_fly(const lame_global_flags *);
  283.  
  284. /* DEPRECATED: now does the same as lame_set_findReplayGain() 
  285.    default = 0 (disabled) */
  286. int CDECL lame_set_ReplayGain_input(lame_global_flags *, int);
  287. int CDECL lame_get_ReplayGain_input(const lame_global_flags *);
  288.  
  289. /* DEPRECATED: now does the same as 
  290.    lame_set_decode_on_the_fly() && lame_set_findReplayGain()
  291.    default = 0 (disabled) */
  292. int CDECL lame_set_ReplayGain_decode(lame_global_flags *, int);
  293. int CDECL lame_get_ReplayGain_decode(const lame_global_flags *);
  294.  
  295. /* DEPRECATED: now does the same as lame_set_decode_on_the_fly() 
  296.    default = 0 (disabled) */
  297. int CDECL lame_set_findPeakSample(lame_global_flags *, int);
  298. int CDECL lame_get_findPeakSample(const lame_global_flags *);
  299.  
  300. /* counters for gapless encoding */
  301. int CDECL lame_set_nogap_total(lame_global_flags*, int);
  302. int CDECL lame_get_nogap_total(const lame_global_flags*);
  303.  
  304. int CDECL lame_set_nogap_currentindex(lame_global_flags* , int);
  305. int CDECL lame_get_nogap_currentindex(const lame_global_flags*);
  306.  
  307.  
  308. /*
  309.  * OPTIONAL:
  310.  * Set printf like error/debug/message reporting functions.
  311.  * The second argument has to be a pointer to a function which looks like
  312.  *   void my_debugf(const char *format, va_list ap)
  313.  *   {
  314.  *       (void) vfprintf(stdout, format, ap);
  315.  *   }
  316.  * If you use NULL as the value of the pointer in the set function, the
  317.  * lame buildin function will be used (prints to stderr).
  318.  * To quiet any output you have to replace the body of the example function
  319.  * with just "return;" and use it in the set function.
  320.  */
  321. int CDECL lame_set_errorf(lame_global_flags *,
  322.                           void (*func)(const char *, va_list));
  323. int CDECL lame_set_debugf(lame_global_flags *,
  324.                           void (*func)(const char *, va_list));
  325. int CDECL lame_set_msgf  (lame_global_flags *,
  326.                           void (*func)(const char *, va_list));
  327.  
  328.  
  329.  
  330. /* set one of brate compression ratio.  default is compression ratio of 11.  */
  331. int CDECL lame_set_brate(lame_global_flags *, int);
  332. int CDECL lame_get_brate(const lame_global_flags *);
  333. int CDECL lame_set_compression_ratio(lame_global_flags *, float);
  334. float CDECL lame_get_compression_ratio(const lame_global_flags *);
  335.  
  336.  
  337. int CDECL lame_set_preset( lame_global_flags*  gfp, int );
  338. int CDECL lame_set_asm_optimizations( lame_global_flags*  gfp, int, int );
  339.  
  340.  
  341.  
  342. /********************************************************************
  343.  *  frame params
  344.  ***********************************************************************/
  345. /* mark as copyright.  default=0 */
  346. int CDECL lame_set_copyright(lame_global_flags *, int);
  347. int CDECL lame_get_copyright(const lame_global_flags *);
  348.  
  349. /* mark as original.  default=1 */
  350. int CDECL lame_set_original(lame_global_flags *, int);
  351. int CDECL lame_get_original(const lame_global_flags *);
  352.  
  353. /* error_protection.  Use 2 bytes from each frame for CRC checksum. default=0 */
  354. int CDECL lame_set_error_protection(lame_global_flags *, int);
  355. int CDECL lame_get_error_protection(const lame_global_flags *);
  356.  
  357. /* padding_type. 0=pad no frames  1=pad all frames 2=adjust padding(default) */
  358. int CDECL lame_set_padding_type(lame_global_flags *, Padding_type);
  359. Padding_type CDECL lame_get_padding_type(const lame_global_flags *);
  360.  
  361. /* MP3 'private extension' bit  Meaningless.  default=0 */
  362. int CDECL lame_set_extension(lame_global_flags *, int);
  363. int CDECL lame_get_extension(const lame_global_flags *);
  364.  
  365. /* enforce strict ISO compliance.  default=0 */
  366. int CDECL lame_set_strict_ISO(lame_global_flags *, int);
  367. int CDECL lame_get_strict_ISO(const lame_global_flags *);
  368.  
  369.  
  370. /********************************************************************
  371.  * quantization/noise shaping 
  372.  ***********************************************************************/
  373.  
  374. /* disable the bit reservoir. For testing only. default=0 */
  375. int CDECL lame_set_disable_reservoir(lame_global_flags *, int);
  376. int CDECL lame_get_disable_reservoir(const lame_global_flags *);
  377.  
  378. /* select a different "best quantization" function. default=0  */
  379. int CDECL lame_set_quant_comp(lame_global_flags *, int);
  380. int CDECL lame_get_quant_comp(const lame_global_flags *);
  381. int CDECL lame_set_quant_comp_short(lame_global_flags *, int);
  382. int CDECL lame_get_quant_comp_short(const lame_global_flags *);
  383.  
  384. int CDECL lame_set_experimentalX(lame_global_flags *, int); /* compatibility*/
  385. int CDECL lame_get_experimentalX(const lame_global_flags *);
  386.  
  387. /* another experimental option.  for testing only */
  388. int CDECL lame_set_experimentalY(lame_global_flags *, int);
  389. int CDECL lame_get_experimentalY(const lame_global_flags *);
  390.  
  391. /* another experimental option.  for testing only */
  392. int CDECL lame_set_experimentalZ(lame_global_flags *, int);
  393. int CDECL lame_get_experimentalZ(const lame_global_flags *);
  394.  
  395. /* Naoki's psycho acoustic model.  default=0 */
  396. int CDECL lame_set_exp_nspsytune(lame_global_flags *, int);
  397. int CDECL lame_get_exp_nspsytune(const lame_global_flags *);
  398.  
  399. void CDECL lame_set_msfix(lame_global_flags *, double);
  400. float CDECL lame_get_msfix(const lame_global_flags *);
  401.  
  402. int lame_set_exp_nspsytune2_int( lame_global_flags*, int, int);
  403. float lame_set_exp_nspsytune2_real( lame_global_flags*, int, float);
  404. void * lame_set_exp_nspsytune2_pointer( lame_global_flags*, int, void *);
  405.  
  406. /********************************************************************
  407.  * VBR control
  408.  ***********************************************************************/
  409. /* Types of VBR.  default = vbr_off = CBR */
  410. int CDECL lame_set_VBR(lame_global_flags *, vbr_mode);
  411. vbr_mode CDECL lame_get_VBR(const lame_global_flags *);
  412.  
  413. /* VBR quality level.  0=highest  9=lowest  */
  414. int CDECL lame_set_VBR_q(lame_global_flags *, int);
  415. int CDECL lame_get_VBR_q(const lame_global_flags *);
  416.  
  417. /* Ignored except for VBR=vbr_abr (ABR mode) */
  418. int CDECL lame_set_VBR_mean_bitrate_kbps(lame_global_flags *, int);
  419. int CDECL lame_get_VBR_mean_bitrate_kbps(const lame_global_flags *);
  420.  
  421. int CDECL lame_set_VBR_min_bitrate_kbps(lame_global_flags *, int);
  422. int CDECL lame_get_VBR_min_bitrate_kbps(const lame_global_flags *);
  423.  
  424. int CDECL lame_set_VBR_max_bitrate_kbps(lame_global_flags *, int);
  425. int CDECL lame_get_VBR_max_bitrate_kbps(const lame_global_flags *);
  426.  
  427. /*
  428.   1=strictly enforce VBR_min_bitrate.  Normally it will be violated for
  429.   analog silence
  430. */
  431. int CDECL lame_set_VBR_hard_min(lame_global_flags *, int);
  432. int CDECL lame_get_VBR_hard_min(const lame_global_flags *);
  433.  
  434. /* for preset */
  435. int CDECL lame_set_preset_expopts(lame_global_flags *, int);
  436.  
  437.  
  438. /********************************************************************
  439.  * Filtering control
  440.  ***********************************************************************/
  441. /* freq in Hz to apply lowpass. Default = 0 = lame chooses.  -1 = disabled */
  442. int CDECL lame_set_lowpassfreq(lame_global_flags *, int);
  443. int CDECL lame_get_lowpassfreq(const lame_global_flags *);
  444. /* width of transition band, in Hz.  Default = one polyphase filter band */
  445. int CDECL lame_set_lowpasswidth(lame_global_flags *, int);
  446. int CDECL lame_get_lowpasswidth(const lame_global_flags *);
  447.  
  448. /* freq in Hz to apply highpass. Default = 0 = lame chooses.  -1 = disabled */
  449. int CDECL lame_set_highpassfreq(lame_global_flags *, int);
  450. int CDECL lame_get_highpassfreq(const lame_global_flags *);
  451. /* width of transition band, in Hz.  Default = one polyphase filter band */
  452. int CDECL lame_set_highpasswidth(lame_global_flags *, int);
  453. int CDECL lame_get_highpasswidth(const lame_global_flags *);
  454.  
  455.  
  456. /********************************************************************
  457.  * psycho acoustics and other arguments which you should not change 
  458.  * unless you know what you are doing
  459.  ***********************************************************************/
  460.  
  461. /* only use ATH for masking */
  462. int CDECL lame_set_ATHonly(lame_global_flags *, int);
  463. int CDECL lame_get_ATHonly(const lame_global_flags *);
  464.  
  465. /* only use ATH for short blocks */
  466. int CDECL lame_set_ATHshort(lame_global_flags *, int);
  467. int CDECL lame_get_ATHshort(const lame_global_flags *);
  468.  
  469. /* disable ATH */
  470. int CDECL lame_set_noATH(lame_global_flags *, int);
  471. int CDECL lame_get_noATH(const lame_global_flags *);
  472.  
  473. /* select ATH formula */
  474. int CDECL lame_set_ATHtype(lame_global_flags *, int);
  475. int CDECL lame_get_ATHtype(const lame_global_flags *);
  476.  
  477. /* lower ATH by this many db */
  478. int CDECL lame_set_ATHlower(lame_global_flags *, float);
  479. float CDECL lame_get_ATHlower(const lame_global_flags *);
  480.  
  481. /* select ATH adaptive adjustment type */
  482. int CDECL lame_set_athaa_type( lame_global_flags *, int);
  483. int CDECL lame_get_athaa_type( const lame_global_flags *);
  484.  
  485. /* select the loudness approximation used by the ATH adaptive auto-leveling  */
  486. int CDECL lame_set_athaa_loudapprox( lame_global_flags *, int);
  487. int CDECL lame_get_athaa_loudapprox( const lame_global_flags *);
  488.  
  489. /* adjust (in dB) the point below which adaptive ATH level adjustment occurs */
  490. int CDECL lame_set_athaa_sensitivity( lame_global_flags *, float);
  491. float CDECL lame_get_athaa_sensitivity( const lame_global_flags* );
  492.  
  493. /* predictability limit (ISO tonality formula) */
  494. int CDECL lame_set_cwlimit(lame_global_flags *, int);
  495. int CDECL lame_get_cwlimit(const lame_global_flags *);
  496.  
  497. /*
  498.   allow blocktypes to differ between channels?
  499.   default: 0 for jstereo, 1 for stereo
  500. */
  501. int CDECL lame_set_allow_diff_short(lame_global_flags *, int);
  502. int CDECL lame_get_allow_diff_short(const lame_global_flags *);
  503.  
  504. /* use temporal masking effect (default = 1) */
  505. int CDECL lame_set_useTemporal(lame_global_flags *, int);
  506. int CDECL lame_get_useTemporal(const lame_global_flags *);
  507.  
  508. /* use temporal masking effect (default = 1) */
  509. int CDECL lame_set_interChRatio(lame_global_flags *, float);
  510. float CDECL lame_get_interChRatio(const lame_global_flags *);
  511.  
  512. /* disable short blocks */
  513. int CDECL lame_set_no_short_blocks(lame_global_flags *, int);
  514. int CDECL lame_get_no_short_blocks(const lame_global_flags *);
  515.  
  516. /* force short blocks */
  517. int CDECL lame_set_force_short_blocks(lame_global_flags *, int);
  518. int CDECL lame_get_force_short_blocks(const lame_global_flags *);
  519.  
  520. /* Input PCM is emphased PCM (for instance from one of the rarely
  521.    emphased CDs), it is STRONGLY not recommended to use this, because
  522.    psycho does not take it into account, and last but not least many decoders
  523.    ignore these bits */
  524. int CDECL lame_set_emphasis(lame_global_flags *, int);
  525. int CDECL lame_get_emphasis(const lame_global_flags *);
  526.  
  527.  
  528.  
  529. /************************************************************************/
  530. /* internal variables, cannot be set...                                 */
  531. /* provided because they may be of use to calling application           */
  532. /************************************************************************/
  533. /* version  0=MPEG-2  1=MPEG-1  (2=MPEG-2.5)     */
  534. int CDECL lame_get_version(const lame_global_flags *);
  535.  
  536. /* encoder delay   */
  537. int CDECL lame_get_encoder_delay(const lame_global_flags *);
  538.  
  539. /*
  540.   padding appended to the input to make sure decoder can fully decode
  541.   all input.  Note that this value can only be calculated during the
  542.   call to lame_encoder_flush().  Before lame_encoder_flush() has
  543.   been called, the value of encoder_padding = 0.
  544. */
  545. int CDECL lame_get_encoder_padding(const lame_global_flags *);
  546.  
  547. /* size of MPEG frame */
  548. int CDECL lame_get_framesize(const lame_global_flags *);
  549.  
  550. /* number of PCM samples buffered, but not yet encoded to mp3 data. */
  551. int CDECL lame_get_mf_samples_to_encode( const lame_global_flags*  gfp );
  552.  
  553. /*
  554.   size (bytes) of mp3 data buffered, but not yet encoded.
  555.   this is the number of bytes which would be output by a call to 
  556.   lame_encode_flush_nogap.  NOTE: lame_encode_flush() will return
  557.   more bytes than this because it will encode the reamining buffered
  558.   PCM samples before flushing the mp3 buffers.
  559. */
  560. int CDECL lame_get_size_mp3buffer( const lame_global_flags*  gfp );
  561.  
  562. /* number of frames encoded so far */
  563. int CDECL lame_get_frameNum(const lame_global_flags *);
  564.  
  565. /*
  566.   lame's estimate of the total number of frames to be encoded
  567.    only valid if calling program set num_samples
  568. */
  569. int CDECL lame_get_totalframes(const lame_global_flags *);
  570.  
  571. /* RadioGain value. Multiplied by 10 and rounded to the nearest. */
  572. int CDECL lame_get_RadioGain(const lame_global_flags *);
  573.  
  574. /* AudiophileGain value. Multipled by 10 and rounded to the nearest. */
  575. int CDECL lame_get_AudiophileGain(const lame_global_flags *);
  576.  
  577. /* the peak sample */
  578. float CDECL lame_get_PeakSample(const lame_global_flags *);
  579.  
  580. /* is decoding on the fly performed */
  581. int CDECL lame_get_decode_on_the_fly(const lame_global_flags *);
  582.  
  583. /* is ReplayGain analysis performed */
  584. int CDECL lame_get_findReplayGain(const lame_global_flags *);
  585.  
  586. /* Gain change required for preventing clipping. The value is correct only if 
  587.    peak sample searching was enabled. If negative then the waveform 
  588.    already does not clip. The value is multiplied by 10 and rounded up. */
  589. int CDECL lame_get_noclipGainChange(const lame_global_flags *);
  590.  
  591. /* user-specified scale factor required for preventing clipping. Value is 
  592.    correct only if peak sample searching was enabled and no user-specified
  593.    scaling was performed. If negative then either the waveform already does
  594.    not clip or the value cannot be determined */
  595. float CDECL lame_get_noclipScale(const lame_global_flags *);
  596.  
  597.  
  598.  
  599.  
  600.  
  601.  
  602.  
  603. /*
  604.  * REQUIRED:
  605.  * sets more internal configuration based on data provided above.
  606.  * returns -1 if something failed.
  607.  */
  608. int CDECL lame_init_params(lame_global_flags * const );
  609.  
  610.  
  611. /*
  612.  * OPTIONAL:
  613.  * get the version number, in a string. of the form:  
  614.  * "3.63 (beta)" or just "3.63". 
  615.  */
  616. const char*  CDECL get_lame_version       ( void );
  617. const char*  CDECL get_lame_short_version ( void );
  618. const char*  CDECL get_lame_very_short_version ( void );
  619. const char*  CDECL get_psy_version        ( void );
  620. const char*  CDECL get_lame_url           ( void );
  621.  
  622. /*
  623.  * OPTIONAL:
  624.  * get the version numbers in numerical form.
  625.  */
  626. typedef struct {
  627.     /* generic LAME version */
  628.     int major;
  629.     int minor;
  630.     int alpha;               /* 0 if not an alpha version                  */
  631.     int beta;                /* 0 if not a beta version                    */
  632.  
  633.     /* version of the psy model */
  634.     int psy_major;
  635.     int psy_minor;
  636.     int psy_alpha;           /* 0 if not an alpha version                  */
  637.     int psy_beta;            /* 0 if not a beta version                    */
  638.  
  639.     /* compile time features */
  640.     const char *features;    /* Don't make assumptions about the contents! */
  641. } lame_version_t;
  642. void CDECL get_lame_version_numerical ( lame_version_t *const );
  643.  
  644.  
  645. /*
  646.  * OPTIONAL:
  647.  * print internal lame configuration to message handler
  648.  */
  649. void CDECL lame_print_config(const lame_global_flags*  gfp);
  650.  
  651. void CDECL lame_print_internals( const lame_global_flags *gfp);
  652.  
  653.  
  654. /*
  655.  * input pcm data, output (maybe) mp3 frames.
  656.  * This routine handles all buffering, resampling and filtering for you.
  657.  * 
  658.  * return code     number of bytes output in mp3buf. Can be 0 
  659.  *                 -1:  mp3buf was too small
  660.  *                 -2:  malloc() problem
  661.  *                 -3:  lame_init_params() not called
  662.  *                 -4:  psycho acoustic problems 
  663.  *
  664.  * The required mp3buf_size can be computed from num_samples, 
  665.  * samplerate and encoding rate, but here is a worst case estimate:
  666.  *
  667.  * mp3buf_size in bytes = 1.25*num_samples + 7200
  668.  *
  669.  * I think a tighter bound could be:  (mt, March 2000)
  670.  * MPEG1:
  671.  *    num_samples*(bitrate/8)/samplerate + 4*1152*(bitrate/8)/samplerate + 512
  672.  * MPEG2:
  673.  *    num_samples*(bitrate/8)/samplerate + 4*576*(bitrate/8)/samplerate + 256
  674.  *
  675.  * but test first if you use that!
  676.  *
  677.  * set mp3buf_size = 0 and LAME will not check if mp3buf_size is
  678.  * large enough.
  679.  *
  680.  * NOTE:
  681.  * if gfp->num_channels=2, but gfp->mode = 3 (mono), the L & R channels
  682.  * will be averaged into the L channel before encoding only the L channel
  683.  * This will overwrite the data in buffer_l[] and buffer_r[].
  684.  * 
  685. */
  686. int CDECL lame_encode_buffer (
  687.         lame_global_flags*  gfp,           /* global context handle         */
  688.         const short int     buffer_l [],   /* PCM data for left channel     */
  689.         const short int     buffer_r [],   /* PCM data for right channel    */
  690.         const int           nsamples,      /* number of samples per channel */
  691.         unsigned char*      mp3buf,        /* pointer to encoded MP3 stream */
  692.         const int           mp3buf_size ); /* number of valid octets in this
  693.                                               stream                        */
  694.  
  695. /*
  696.  * as above, but input has L & R channel data interleaved.
  697.  * NOTE: 
  698.  * num_samples = number of samples in the L (or R)
  699.  * channel, not the total number of samples in pcm[]  
  700.  */
  701. int CDECL lame_encode_buffer_interleaved(
  702.         lame_global_flags*  gfp,           /* global context handlei        */
  703.         short int           pcm[],         /* PCM data for left and right
  704.                                               channel, interleaved          */
  705.         int                 num_samples,   /* number of samples per channel,
  706.                                               _not_ number of samples in
  707.                                               pcm[]                         */
  708.         unsigned char*      mp3buf,        /* pointer to encoded MP3 stream */
  709.         int                 mp3buf_size ); /* number of valid octets in this
  710.                                               stream                        */
  711.  
  712.  
  713. /* as lame_encode_buffer, but for 'float's.
  714.  * !! NOTE: !! data must still be scaled to be in the same range as 
  715.  * short int, +/- 32768  
  716.  */
  717. int CDECL lame_encode_buffer_float(
  718.         lame_global_flags*  gfp,           /* global context handle         */
  719.         const float     buffer_l [],       /* PCM data for left channel     */
  720.         const float     buffer_r [],       /* PCM data for right channel    */
  721.         const int           nsamples,      /* number of samples per channel */
  722.         unsigned char*      mp3buf,        /* pointer to encoded MP3 stream */
  723.         const int           mp3buf_size ); /* number of valid octets in this
  724.                                               stream                        */
  725.  
  726.  
  727. /* as lame_encode_buffer, but for long's 
  728.  * !! NOTE: !! data must still be scaled to be in the same range as 
  729.  * short int, +/- 32768  
  730.  *
  731.  * This scaling was a mistake (doesn't allow one to exploit full
  732.  * precision of type 'long'.  Use lame_encode_buffer_long2() instead.
  733.  *
  734.  */
  735. int CDECL lame_encode_buffer_long(
  736.         lame_global_flags*  gfp,           /* global context handle         */
  737.         const long     buffer_l [],       /* PCM data for left channel     */
  738.         const long     buffer_r [],       /* PCM data for right channel    */
  739.         const int           nsamples,      /* number of samples per channel */
  740.         unsigned char*      mp3buf,        /* pointer to encoded MP3 stream */
  741.         const int           mp3buf_size ); /* number of valid octets in this
  742.                                               stream                        */
  743.  
  744. /* Same as lame_encode_buffer_long(), but with correct scaling. 
  745.  * !! NOTE: !! data must still be scaled to be in the same range as  
  746.  * type 'long'.   Data should be in the range:  +/- 2^(8*size(long)-1)
  747.  *
  748.  */
  749. int CDECL lame_encode_buffer_long2(
  750.         lame_global_flags*  gfp,           /* global context handle         */
  751.         const long     buffer_l [],       /* PCM data for left channel     */
  752.         const long     buffer_r [],       /* PCM data for right channel    */
  753.         const int           nsamples,      /* number of samples per channel */
  754.         unsigned char*      mp3buf,        /* pointer to encoded MP3 stream */
  755.         const int           mp3buf_size ); /* number of valid octets in this
  756.                                               stream                        */
  757.  
  758. /* as lame_encode_buffer, but for int's 
  759.  * !! NOTE: !! input should be scaled to the maximum range of 'int'
  760.  * If int is 4 bytes, then the values should range from
  761.  * +/- 2147483648.  
  762.  *
  763.  * This routine does not (and cannot, without loosing precision) use
  764.  * the same scaling as the rest of the lame_encode_buffer() routines.
  765.  * 
  766.  */   
  767. int CDECL lame_encode_buffer_int(
  768.         lame_global_flags*  gfp,           /* global context handle         */
  769.         const int      buffer_l [],       /* PCM data for left channel     */
  770.         const int      buffer_r [],       /* PCM data for right channel    */
  771.         const int           nsamples,      /* number of samples per channel */
  772.         unsigned char*      mp3buf,        /* pointer to encoded MP3 stream */
  773.         const int           mp3buf_size ); /* number of valid octets in this
  774.                                               stream                        */
  775.  
  776.  
  777.  
  778.  
  779.  
  780. /*
  781.  * REQUIRED:
  782.  * lame_encode_flush will flush the intenal PCM buffers, padding with 
  783.  * 0's to make sure the final frame is complete, and then flush
  784.  * the internal MP3 buffers, and thus may return a 
  785.  * final few mp3 frames.  'mp3buf' should be at least 7200 bytes long
  786.  * to hold all possible emitted data.
  787.  *
  788.  * will also write id3v1 tags (if any) into the bitstream       
  789.  *
  790.  * return code = number of bytes output to mp3buf. Can be 0
  791.  */
  792. int CDECL lame_encode_flush(
  793.         lame_global_flags *  gfp,    /* global context handle                 */
  794.         unsigned char*       mp3buf, /* pointer to encoded MP3 stream         */
  795.         int                  size);  /* number of valid octets in this stream */
  796.  
  797. /*
  798.  * OPTIONAL:
  799.  * lame_encode_flush_nogap will flush the internal mp3 buffers and pad
  800.  * the last frame with ancillary data so it is a complete mp3 frame.
  801.  * 
  802.  * 'mp3buf' should be at least 7200 bytes long
  803.  * to hold all possible emitted data.
  804.  *
  805.  * After a call to this routine, the outputed mp3 data is complete, but
  806.  * you may continue to encode new PCM samples and write future mp3 data
  807.  * to a different file.  The two mp3 files will play back with no gaps
  808.  * if they are concatenated together.
  809.  *
  810.  * This routine will NOT write id3v1 tags into the bitstream.
  811.  *
  812.  * return code = number of bytes output to mp3buf. Can be 0
  813.  */
  814. int CDECL lame_encode_flush_nogap(
  815.         lame_global_flags *  gfp,    /* global context handle                 */
  816.         unsigned char*       mp3buf, /* pointer to encoded MP3 stream         */
  817.         int                  size);  /* number of valid octets in this stream */
  818.  
  819. /*
  820.  * OPTIONAL:
  821.  * Normally, this is called by lame_init_params().  It writes id3v2 and
  822.  * Xing headers into the front of the bitstream, and sets frame counters
  823.  * and bitrate histogram data to 0.  You can also call this after 
  824.  * lame_encode_flush_nogap().  
  825.  */
  826. int CDECL lame_init_bitstream(
  827.         lame_global_flags *  gfp);    /* global context handle                 */
  828.  
  829.  
  830.  
  831. /*
  832.  * OPTIONAL:    some simple statistics
  833.  * a bitrate histogram to visualize the distribution of used frame sizes
  834.  * a stereo mode histogram to visualize the distribution of used stereo
  835.  *   modes, useful in joint-stereo mode only
  836.  *   0: LR    left-right encoded
  837.  *   1: LR-I  left-right and intensity encoded (currently not supported)
  838.  *   2: MS    mid-side encoded
  839.  *   3: MS-I  mid-side and intensity encoded (currently not supported)
  840.  *
  841.  * attention: don't call them after lame_encode_finish
  842.  * suggested: lame_encode_flush -> lame_*_hist -> lame_close
  843.  */
  844.  
  845. void CDECL lame_bitrate_hist( 
  846.         const lame_global_flags *const gfp, 
  847.               int                      bitrate_count[14] );
  848. void CDECL lame_bitrate_kbps( 
  849.         const lame_global_flags *const gfp, 
  850.               int                      bitrate_kbps [14] );
  851. void CDECL lame_stereo_mode_hist( 
  852.         const lame_global_flags *const gfp, 
  853.               int                      stereo_mode_count[4] );
  854.  
  855. void CDECL lame_bitrate_stereo_mode_hist ( 
  856.         const lame_global_flags * const gfp, 
  857.         int  bitrate_stmode_count [14] [4] );
  858.  
  859. void CDECL lame_block_type_hist (
  860.         const lame_global_flags * const gfp, 
  861.         int btype_count[6] );
  862.  
  863. void CDECL lame_bitrate_block_type_hist ( 
  864.         const lame_global_flags * const gfp, 
  865.         int bitrate_btype_count[14][6] );
  866.  
  867.  
  868. /*
  869.  * OPTIONAL:
  870.  * lame_mp3_tags_fid will append a Xing VBR tag to the mp3 file with file
  871.  * pointer fid.  These calls perform forward and backwards seeks, so make
  872.  * sure fid is a real file.  Make sure lame_encode_flush has been called,
  873.  * and all mp3 data has been written to the file before calling this
  874.  * function.
  875.  * NOTE:
  876.  * if VBR  tags are turned off by the user, or turned off by LAME because
  877.  * the output is not a regular file, this call does nothing
  878. */
  879. void CDECL lame_mp3_tags_fid(lame_global_flags *,FILE* fid);
  880.  
  881.  
  882. /*
  883.  * REQUIRED:
  884.  * final call to free all remaining buffers
  885.  */
  886. int  CDECL lame_close (lame_global_flags *);
  887.  
  888. /*
  889.  * OBSOLETE:
  890.  * lame_encode_finish combines lame_encode_flush() and lame_close() in
  891.  * one call.  However, once this call is made, the statistics routines
  892.  * will no longer work because the data will have been cleared, and
  893.  * lame_mp3_tags_fid() cannot be called to add data to the VBR header  
  894.  */
  895. int CDECL lame_encode_finish(
  896.         lame_global_flags*  gfp,
  897.         unsigned char*      mp3buf,
  898.         int                 size );
  899.  
  900.  
  901.  
  902.  
  903.  
  904.  
  905.  
  906. /*********************************************************************
  907.  *
  908.  * decoding 
  909.  *
  910.  * a simple interface to mpglib, part of mpg123, is also included if
  911.  * libmp3lame is compiled with HAVE_MPGLIB
  912.  *
  913.  *********************************************************************/
  914. typedef struct {
  915.   int header_parsed;   /* 1 if header was parsed and following data was
  916.                           computed                                       */
  917.   int stereo;          /* number of channels                             */
  918.   int samplerate;      /* sample rate                                    */
  919.   int bitrate;         /* bitrate                                        */
  920.   int mode;            /* mp3 frame type                                 */
  921.   int mode_ext;        /* mp3 frame type                                 */
  922.   int framesize;       /* number of samples per mp3 frame                */
  923.  
  924.   /* this data is only computed if mpglib detects a Xing VBR header */
  925.   unsigned long nsamp; /* number of samples in mp3 file.                 */
  926.   int totalframes;     /* total number of frames in mp3 file             */
  927.  
  928.   /* this data is not currently computed by the mpglib routines */
  929.   int framenum;        /* frames decoded counter                         */
  930. } mp3data_struct;
  931.  
  932.  
  933. /* required call to initialize decoder 
  934.  * NOTE: the decoder should not be used when encoding is performed
  935.  * with decoding on the fly */
  936. int CDECL lame_decode_init(void);
  937.  
  938. /*********************************************************************
  939.  * input 1 mp3 frame, output (maybe) pcm data.  
  940.  *
  941.  *  nout = lame_decode(mp3buf,len,pcm_l,pcm_r);
  942.  *
  943.  * input:  
  944.  *    len          :  number of bytes of mp3 data in mp3buf
  945.  *    mp3buf[len]  :  mp3 data to be decoded
  946.  *
  947.  * output:
  948.  *    nout:  -1    : decoding error
  949.  *            0    : need more data before we can complete the decode 
  950.  *           >0    : returned 'nout' samples worth of data in pcm_l,pcm_r
  951.  *    pcm_l[nout]  : left channel data
  952.  *    pcm_r[nout]  : right channel data 
  953.  *    
  954.  *********************************************************************/
  955. int CDECL lame_decode(
  956.         unsigned char *  mp3buf,
  957.         int              len,
  958.         short            pcm_l[],
  959.         short            pcm_r[] );
  960.  
  961. /* same as lame_decode, and also returns mp3 header data */
  962. int CDECL lame_decode_headers(
  963.         unsigned char*   mp3buf,
  964.         int              len,
  965.         short            pcm_l[],
  966.         short            pcm_r[],
  967.         mp3data_struct*  mp3data );
  968.  
  969. /* same as lame_decode, but returns at most one frame */
  970. int CDECL lame_decode1(
  971.         unsigned char*  mp3buf,
  972.         int             len,
  973.         short           pcm_l[],
  974.         short           pcm_r[] );
  975.  
  976. /* same as lame_decode1, but returns at most one frame and mp3 header data */
  977. int CDECL lame_decode1_headers(
  978.         unsigned char*   mp3buf,
  979.         int              len,
  980.         short            pcm_l[],
  981.         short            pcm_r[],
  982.         mp3data_struct*  mp3data );
  983.  
  984. /* same as lame_decode1_headers, but also returns enc_delay and enc_padding
  985.    from VBR Info tag, (-1 if no info tag was found) */
  986. int CDECL lame_decode1_headersB(
  987.         unsigned char*   mp3buf,
  988.         int              len,
  989.         short            pcm_l[],
  990.         short            pcm_r[],
  991.         mp3data_struct*  mp3data,
  992.         int              *enc_delay,
  993.         int              *enc_padding );
  994.  
  995.  
  996. /* cleanup call to exit decoder  */
  997. int CDECL lame_decode_exit(void);
  998.  
  999.  
  1000.  
  1001. /*********************************************************************
  1002.  *
  1003.  * id3tag stuff
  1004.  *
  1005.  *********************************************************************/
  1006.  
  1007. /*
  1008.  * id3tag.h -- Interface to write ID3 version 1 and 2 tags.
  1009.  *
  1010.  * Copyright (C) 2000 Don Melton.
  1011.  *
  1012.  * This library is free software; you can redistribute it and/or
  1013.  * modify it under the terms of the GNU Library General Public
  1014.  * License as published by the Free Software Foundation; either
  1015.  * version 2 of the License, or (at your option) any later version.
  1016.  *
  1017.  * This library is distributed in the hope that it will be useful,
  1018.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  1019.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  1020.  * Library General Public License for more details.
  1021.  *
  1022.  * You should have received a copy of the GNU Library General Public
  1023.  * License along with this library; if not, write to the Free Software
  1024.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  1025.  */
  1026.  
  1027. /* utility to obtain alphabetically sorted list of genre names with numbers */
  1028. extern void id3tag_genre_list(
  1029.         void (*handler)(int, const char *, void *),
  1030.         void*  cookie);
  1031.  
  1032. extern void id3tag_init   (lame_global_flags *gfp);
  1033.  
  1034. /* force addition of version 2 tag */
  1035. extern void id3tag_add_v2   (lame_global_flags *gfp);
  1036.  
  1037. /* add only a version 1 tag */
  1038. extern void id3tag_v1_only  (lame_global_flags *gfp);
  1039.  
  1040. /* add only a version 2 tag */
  1041. extern void id3tag_v2_only  (lame_global_flags *gfp);
  1042.  
  1043. /* pad version 1 tag with spaces instead of nulls */
  1044. extern void id3tag_space_v1 (lame_global_flags *gfp);
  1045.  
  1046. /* pad version 2 tag with extra 128 bytes */
  1047. extern void id3tag_pad_v2   (lame_global_flags *gfp);
  1048.  
  1049. extern void id3tag_set_title(
  1050.         lame_global_flags*  gfp,
  1051.         const char*         title );
  1052. extern void id3tag_set_artist(
  1053.         lame_global_flags*  gfp,
  1054.         const char*         artist );
  1055. extern void id3tag_set_album(
  1056.         lame_global_flags*  gfp,
  1057.         const char*         album );
  1058. extern void id3tag_set_year(
  1059.         lame_global_flags*  gfp,
  1060.         const char*         year );
  1061. extern void id3tag_set_comment(
  1062.         lame_global_flags*  gfp,
  1063.         const char*         comment );
  1064. extern void id3tag_set_track(
  1065.         lame_global_flags*  gfp,
  1066.         const char*         track );
  1067.  
  1068. /* return non-zero result if genre name or number is invalid */
  1069. extern int id3tag_set_genre(
  1070.         lame_global_flags*  gfp,
  1071.         const char*         genre );
  1072.  
  1073. /***********************************************************************
  1074. *
  1075. *  list of valid bitrates [kbps] & sample frequencies [Hz].
  1076. *  first index: 0: MPEG-2   values  (sample frequencies 16...24 kHz) 
  1077. *               1: MPEG-1   values  (sample frequencies 32...48 kHz)
  1078. *               2: MPEG-2.5 values  (sample frequencies  8...12 kHz)
  1079. ***********************************************************************/
  1080. extern const int      bitrate_table    [3] [16];
  1081. extern const int      samplerate_table [3] [ 4];
  1082.  
  1083.  
  1084.  
  1085. /* maximum size of mp3buffer needed if you encode at most 1152 samples for
  1086.    each call to lame_encode_buffer.  see lame_encode_buffer() below  
  1087.    (LAME_MAXMP3BUFFER is now obsolete)  */
  1088. #define LAME_MAXMP3BUFFER   16384
  1089.  
  1090.  
  1091. typedef enum {
  1092.     LAME_OKAY             =   0,
  1093.     LAME_NOERROR          =   0,
  1094.     LAME_GENERICERROR     =  -1,
  1095.     LAME_NOMEM            = -10,
  1096.     LAME_BADBITRATE       = -11,
  1097.     LAME_BADSAMPFREQ      = -12,
  1098.     LAME_INTERNALERROR    = -13,
  1099.     
  1100.     FRONTEND_READERROR    = -80,
  1101.     FRONTEND_WRITEERROR   = -81,
  1102.     FRONTEND_FILETOOLARGE = -82
  1103.     
  1104. } lame_errorcodes_t;
  1105.  
  1106. #if defined(__cplusplus)
  1107. }
  1108. #endif
  1109. #endif /* LAME_LAME_H */
  1110.  
  1111.