Subversion Repositories planix.SVN

/*{{{ #defines                        */

#include <limits.h>

#include "lame.h"

#include "util.h"

#define ENCDELAY      576

#define MDCTDELAY     48

#define BLKSIZE       1024

#define HBLKSIZE      (BLKSIZE/2 + 1)

#define BLKSIZE_s     256

#define HBLKSIZE_s    (BLKSIZE_s/2 + 1)

#define MAX_TABLES    1002

#define TAPS          32

#define WINDOW_SIZE   15.5

#define WINDOW        hanning

#define inline        __inline

#define MIN(a,b)      ((a) < (b) ? (a) : (b))

#define MAX(a,b)      ((a) > (b) ? (a) : (b))

#ifndef M_PIl

# define M_PIl          3.1415926535897932384626433832795029L

#endif

#define SIN             sin

#define COS             cos

/*}}}*/

/*{{{ object ID's                     */

#define RESAMPLE_ID     0x52455341LU

#define PSYCHO_ID       0x50535943LU

#define BITSTREAM_ID    0x42495453LU

/*}}}*/

/*{{{ typedef's                       */

typedef float         float32_t;                   // IEEE-754 32 bit floating point

typedef double        float64_t;                   // IEEE-754 64 bit floating point

typedef long double   float80_t;                   // IEEE-854 80 bit floating point, if available

typedef long double   float_t;                     // temporarly results of float operations

typedef long double   double_t;                    // temporarly results of double operations

typedef long double   longdouble_t;                // temporarly results of long double operations

typedef float_t (*scalar_t)  ( const sample_t* p, const sample_t* q );

typedef float_t (*scalarn_t) ( const sample_t* p, const sample_t* q, size_t len );

/*}}}*/

/*{{{ data direction attributes       */

/*

 * These are data stream direction attributes like used in Ada83/Ada95 and in RPC

 * The data direction is seen from the caller to the calling function.

 * Examples:

 *

 *    size_t  fread  ( void INOUT* buffer, size_t items, size_t itemsize, FILE INOUT* fp );

 *    size_t  fwrite ( void OUT  * buffer, size_t items, size_t itemsize, FILE INOUT* fp );

 *    size_t  memset ( void IN   * buffer, unsigned char value, size_t size );

 *

 * Return values are implizit IN (note that here C uses the opposite attribute).

 * Arguments not transmitted via references are implizit OUT.

 */

#define OUT            /* [out]   */ const

#define INOUT          /* [inout] */

#define IN             /* [in]    */

#define OUTTR          /* [out]: data is modified like [inout], but you don't get any useful back */

/*}}}*/

/*{{{ Test some error conditions      */

#ifndef __LOC__

# define _STR2(x)      #x

# define _STR1(x)      _STR2(x)

# define __LOC__       __FILE__ "(" _STR1(__LINE__) ") : warning: "

#endif

/* The current code doesn't work on machines with non 8 bit char's in any way, so abort */

#if CHAR_BIT != 8

# pragma message ( __LOC__ "Machines with CHAR_BIT != 8 not yet supported" )

# pragma error

#endif

/*}}}*/

/*

 *  Now some information how PCM data can be specified. PCM data

 *  is specified by 3 attributes: pointer, length information

 *  and attributes.

 *    - Audio is always stored in 2D arrays, which are collapsing to 1D

 *      in the case of monaural input

 *    - 2D arrays can be stored as 2D arrays or as pointers to 1D arrays.

 *    - 2D data can be stored as samples*channels or as channels*samples

 *    - This gives 4 kinds of storing PCM data:

 *      + pcm [samples][channels]       (LAME_INTERLEAVED)

 *      + pcm [channels][samples]       (LAME_CHAINED)

 *      + (*pcm) [samples]              (LAME_INDIRECT)

 *      + (*pcm) [channels]

 *    - The last I have never seen and it have a huge overhead (67% ... 200%),

 *      so the first three are implemented.

 *    - The monaural 1D cases can also be handled by the first two attributes

 */

#define  LAME_INTERLEAVED       0x10000000

#define  LAME_CHAINED           0x20000000

#define  LAME_INDIRECT          0x30000000

/*

 *  Now we need some information about the byte order of the data.

 *  There are 4 cases possible (if you are not fully support such strange

 *  Machines like the PDPs):

 *    - You know the absolute byte order of the data (LAME_LITTLE_ENDIAN, LAME_BIG_ENDIAN)

 *    - You know the byte order from the view of the current machine

 *      (LAME_NATIVE_ENDIAN, LAME_OPPOSITE_ENDIAN)

 *    - The use of LAME_OPPOSITE_ENDIAN is NOT recommended because it is

 *      is a breakable attribute, use LAME_LITTLE_ENDIAN or LAME_BIG_ENDIAN

 *      instead

 */

#define  LAME_NATIVE_ENDIAN     0x00000000

#define  LAME_OPPOSITE_ENDIAN   0x01000000

#define  LAME_LITTLE_ENDIAN     0x02000000

#define  LAME_BIG_ENDIAN        0x03000000

/*

 *  The next attribute is the data type of the input data.

 *  There are currently 2 kinds of input data:

 *    - C based:

 *          LAME_{SHORT,INT,LONG}

 *          LAME_{FLOAT,DOUBLE,LONGDOUBLE}

 *    - Binary representation based:

 *          LAME_{UINT,INT}{8,16,24,32}

 *          LAME_{A,U}LAW

 *          LAME_FLOAT{32,64,80_ALIGN{2,4,8}}

 *

 *  Don't use the C based for external data.

 */

#define  LAME_SILENCE           0x00010000

#define  LAME_UINT8             0x00020000

#define  LAME_INT8              0x00030000

#define  LAME_UINT16            0x00040000

#define  LAME_INT16             0x00050000

#define  LAME_UINT24            0x00060000

#define  LAME_INT24             0x00070000

#define  LAME_UINT32            0x00080000

#define  LAME_INT32             0x00090000

#define  LAME_FLOAT32           0x00140000

#define  LAME_FLOAT64           0x00180000

#define  LAME_FLOAT80_ALIGN2    0x001A0000

#define  LAME_FLOAT80_ALIGN4    0x001C0000

#define  LAME_FLOAT80_ALIGN8    0x00200000

#define  LAME_SHORT             0x00210000

#define  LAME_INT               0x00220000

#define  LAME_LONG              0x00230000

#define  LAME_FLOAT             0x00240000

#define  LAME_DOUBLE            0x00250000

#define  LAME_LONGDOUBLE        0x00260000

#define  LAME_ALAW              0x00310000

#define  LAME_ULAW              0x00320000

/*

 *  The last attribute is the number of input channels. Currently

 *  1...65535 channels are possible, but only 1 and 2 are supported.

 *  So matrixing or MPEG-2 MultiChannelSupport are not a big problem.

 *

 *  Note: Some people use the word 'stereo' for 2 channel stereophonic sound.

 *        But stereophonic sound is a collection of ALL methods to restore the

 *        stereophonic sound field starting from 2 channels up to audio

 *        holography.

 */

#define LAME_MONO               0x00000001

#define LAME_STEREO             0x00000002

#define LAME_STEREO_2_CHANNELS  0x00000002

#define LAME_STEREO_3_CHANNELS  0x00000003

#define LAME_STEREO_4_CHANNELS  0x00000004

#define LAME_STEREO_5_CHANNELS  0x00000005

#define LAME_STEREO_6_CHANNELS  0x00000006

#define LAME_STEREO_7_CHANNELS  0x00000007

#define LAME_STEREO_65535_CHANNELS\

                                0x0000FFFF

extern scalar_t   scalar4;

extern scalar_t   scalar8;

extern scalar_t   scalar12;

extern scalar_t   scalar16;

extern scalar_t   scalar20;

extern scalar_t   scalar24;

extern scalar_t   scalar32;

extern scalarn_t  scalar4n;

extern scalarn_t  scalar1n;

float_t  scalar04_float32_i387  ( const float32_t* p, const float32_t* q );

float_t  scalar08_float32_i387  ( const float32_t* p, const float32_t* q );

float_t  scalar12_float32_i387  ( const float32_t* p, const float32_t* q );

float_t  scalar16_float32_i387  ( const float32_t* p, const float32_t* q );

float_t  scalar20_float32_i387  ( const float32_t* p, const float32_t* q );

float_t  scalar24_float32_i387  ( const float32_t* p, const float32_t* q );

float_t  scalar32_float32_i387  ( const float32_t* p, const float32_t* q );

float_t  scalar4n_float32_i387  ( const float32_t* p, const float32_t* q, const size_t len );

float_t  scalar1n_float32_i387  ( const float32_t* p, const float32_t* q, const size_t len );

float_t  scalar04_float32_3DNow ( const float32_t* p, const float32_t* q );

float_t  scalar08_float32_3DNow ( const float32_t* p, const float32_t* q );

float_t  scalar12_float32_3DNow ( const float32_t* p, const float32_t* q );

float_t  scalar16_float32_3DNow ( const float32_t* p, const float32_t* q );

float_t  scalar20_float32_3DNow ( const float32_t* p, const float32_t* q );

float_t  scalar24_float32_3DNow ( const float32_t* p, const float32_t* q );

float_t  scalar32_float32_3DNow ( const float32_t* p, const float32_t* q );

float_t  scalar4n_float32_3DNow ( const float32_t* p, const float32_t* q, const size_t len );

float_t  scalar1n_float32_3DNow ( const float32_t* p, const float32_t* q, const size_t len );

float_t  scalar04_float32_SIMD  ( const float32_t* p, const float32_t* q );

float_t  scalar08_float32_SIMD  ( const float32_t* p, const float32_t* q );

float_t  scalar12_float32_SIMD  ( const float32_t* p, const float32_t* q );

float_t  scalar16_float32_SIMD  ( const float32_t* p, const float32_t* q );

float_t  scalar20_float32_SIMD  ( const float32_t* p, const float32_t* q );

float_t  scalar24_float32_SIMD  ( const float32_t* p, const float32_t* q );

float_t  scalar32_float32_SIMD  ( const float32_t* p, const float32_t* q );

float_t  scalar4n_float32_SIMD  ( const float32_t* p, const float32_t* q, const size_t len );

float_t  scalar1n_float32_SIMD  ( const float32_t* p, const float32_t* q, const size_t len );

float_t  scalar04_float32       ( const float32_t* p, const float32_t* q );

float_t  scalar08_float32       ( const float32_t* p, const float32_t* q );

float_t  scalar12_float32       ( const float32_t* p, const float32_t* q );

float_t  scalar16_float32       ( const float32_t* p, const float32_t* q );

float_t  scalar20_float32       ( const float32_t* p, const float32_t* q );

float_t  scalar24_float32       ( const float32_t* p, const float32_t* q );

float_t  scalar32_float32       ( const float32_t* p, const float32_t* q );

float_t  scalar4n_float32       ( const float32_t* p, const float32_t* q, const size_t len );

float_t  scalar1n_float32       ( const float32_t* p, const float32_t* q, const size_t len );

/*{{{ some prototypes                 */

resample_t*  resample_open (

        OUT long double  sampfreq_in,    // [Hz]

        OUT long double  sampfreq_out,   // [Hz]

        OUT double       lowpass_freq,   // [Hz] or <0 for auto mode

        OUT int          quality );      // Proposal: 0 default, 1 sample select, 2 linear interpol, 4 4-point interpolation, 32 32-point interpolation

int  resample_buffer (                          // return code, 0 for success

        INOUT resample_t *const   r,            // internal structure

        IN    sample_t   *const   out,          // where to write the output data

        INOUT size_t     *const   out_req_len,  // requested output data len/really written output data len

        OUT   sample_t   *const   in,           // where are the input data?

        INOUT size_t     *const   in_avail_len, // available input data len/consumed input data len

        OUT   size_t              channel );    // number of the channel (needed for buffering)

int  resample_close ( INOUT resample_t* const r );

void         init_scalar_functions   ( OUT lame_t* const lame );

long double  unround_samplefrequency ( OUT long double freq );

#if 0

int  lame_encode_mp3_frame (             // return code, 0 for success

        INOUT lame_global_flags*,        // internal context structure

        OUTTR sample_t * inbuf_l,        // data for left  channel

        OUTTR sample_t * inbuf_r,        // data for right channel

        IN    uint8_t  * mp3buf,         // where to write the coded data

        OUT   size_t     mp3buf_size );  // maximum size of coded data

#endif

int  lame_encode_ogg_frame (             // return code, 0 for success

        INOUT lame_global_flags*,        // internal context structure

        OUT   sample_t * inbuf_l,        // data for left  channel

        OUT   sample_t * inbuf_r,        // data for right channel

        IN    uint8_t  * mp3buf,         // where to write the coded data

        OUT   size_t     mp3buf_size );  // maximum size of coded data

/*}}}*/

/* end of pcm.h */