/*

mpg123lib_intern: Common non-public stuff for libmpg123

copyright 1995-2008 by the mpg123 project - free software under the terms of the LGPL 2.1

see COPYING and AUTHORS files in distribution or http://mpg123.org

derived from the old mpg123.h

*/

#ifndef MPG123_H_INTERN

#define MPG123_H_INTERN

#define MPG123_RATES 9

#define MPG123_ENCODINGS 12

#include "config.h" /* Load this before _anything_ */

#include "intsym.h" /* Prefixing of internal symbols that still are public in a static lib. */

#include "abi_align.h"

/* export DLL symbols */

#if (defined(_WIN32) || defined(__OS2__)) && defined(DYNAMIC_BUILD)

#define BUILD_MPG123_DLL

#endif

#include "compat.h"

#include "mpg123.h"

#define SKIP_JUNK 1

#ifndef M_PI

# define M_PI 3.14159265358979323846

#endif

#ifndef M_SQRT2

# define M_SQRT2 1.41421356237309504880

#endif

#ifdef SUNOS

#define memmove(dst,src,size) bcopy(src,dst,size)

#endif

/* We don't really do long double... there are 3 options for REAL:

float, long and double. */

#ifdef REAL_IS_FLOAT

# define real float

#elif defined(REAL_IS_FIXED)

# define real int32_t

# define dreal int64_t

/*

for fixed-point decoders, use pre-calculated tables to avoid expensive floating-point maths

undef this macro for run-time calculation

*/

#define PRECALC_TABLES

# define REAL_RADIX 24

# define REAL_FACTOR 16777216.0

static inline int32_t double_to_long_rounded(double x, double scalefac)

{

x *= scalefac;

x += (x > 0) ? 0.5 : -0.5;

return (int32_t)x;

}

static inline int32_t scale_rounded(int32_t x, int shift)

{

x += (x >> 31);

x >>= (shift - 1);

x += (x & 1);

return (x >> 1);

}

# ifdef __GNUC__

# if defined(OPT_I386)

/* for i386_nofpu decoder */

# define REAL_MUL_ASM(x, y, radix) \

({ \

long _x=(x), _y=(y); \

__asm__ ( \

"imull %1 \n\t" \

"shrdl %2, %%edx, %0 \n\t" \

: "+&a" (_x) \

: "mr" (_y), "I" (radix) \

: "%edx", "cc" \

); \

_x; \

})

# define REAL_MUL_SCALE_LAYER3_ASM(x, y, radix) \

({ \

long _x=(x), _y=(y), _radix=(radix); \

__asm__ ( \

"imull %1 \n\t" \

"shrdl %%cl, %%edx, %0 \n\t" \

: "+&a" (_x) \

: "mr" (_y), "c" (_radix) \

: "%edx", "cc" \

); \

_x; \

})

# elif defined(OPT_PPC)

/* for powerpc */

# define REAL_MUL_ASM(x, y, radix) \

({ \

long _x=(x), _y=(y), _mull, _mulh; \

__asm__ ( \

"mullw %0, %2, %3 \n\t" \

"mulhw %1, %2, %3 \n\t" \

"srwi %0, %0, %4 \n\t" \

"rlwimi %0, %1, %5, 0, %6 \n\t" \

: "=&r" (_mull), "=&r" (_mulh) \

: "r" (_x), "r" (_y), "i" (radix), "i" (32-(radix)), "i" ((radix)-1) \

); \

_mull; \

})

# define REAL_MUL_SCALE_LAYER3_ASM(x, y, radix) \

({ \

long _x=(x), _y=(y), _radix=(radix), _mull, _mulh, _radix2; \

__asm__ ( \

"mullw %0, %3, %4 \n\t" \

"mulhw %1, %3, %4 \n\t" \

"subfic %2, %5, 32 \n\t" \

"srw %0, %0, %5 \n\t" \

"slw %1, %1, %2 \n\t" \

"or %0, %0, %1 \n\t" \

: "=&r" (_mull), "=&r" (_mulh), "=&r" (_radix2) \

: "r" (_x), "r" (_y), "r" (_radix) \

: "cc" \

); \

_mull; \

})

# elif defined(OPT_ARM)

/* for arm */

# define REAL_MUL_ASM(x, y, radix) \

({ \

long _x=(x), _y=(y), _mull, _mulh; \

__asm__ ( \

"smull %0, %1, %2, %3 \n\t" \

"mov %0, %0, lsr %4 \n\t" \

"orr %0, %0, %1, lsl %5 \n\t" \

: "=&r" (_mull), "=&r" (_mulh) \

: "r" (_x), "r" (_y), "M" (radix), "M" (32-(radix)) \

); \

_mull; \

})

# define REAL_MUL_SCALE_LAYER3_ASM(x, y, radix) \

({ \

long _x=(x), _y=(y), _radix=(radix), _mull, _mulh, _radix2; \

__asm__ ( \

"smull %0, %1, %3, %4 \n\t" \

"mov %0, %0, lsr %5 \n\t" \

"rsb %2, %5, #32 \n\t" \

"mov %1, %1, lsl %2 \n\t" \

"orr %0, %0, %1 \n\t" \

: "=&r" (_mull), "=&r" (_mulh), "=&r" (_radix2) \

: "r" (_x), "r" (_y), "r" (_radix) \

); \

_mull; \

})

# endif

# endif

/* I just changed the (int) to (real) there... seemed right. */

# define DOUBLE_TO_REAL(x) (double_to_long_rounded(x, REAL_FACTOR))

# define DOUBLE_TO_REAL_15(x) (double_to_long_rounded(x, 32768.0))

# define DOUBLE_TO_REAL_POW43(x) (double_to_long_rounded(x, 8192.0))

# define DOUBLE_TO_REAL_SCALE_LAYER12(x) (double_to_long_rounded(x, 1073741824.0))

# define DOUBLE_TO_REAL_SCALE_LAYER3(x, y) (double_to_long_rounded(x, pow(2.0,gainpow2_scale[y])))

# define REAL_TO_DOUBLE(x) ((double)(x) / REAL_FACTOR)

# ifdef REAL_MUL_ASM

# define REAL_MUL(x, y) REAL_MUL_ASM(x, y, REAL_RADIX)

# define REAL_MUL_15(x, y) REAL_MUL_ASM(x, y, 15)

# define REAL_MUL_SCALE_LAYER12(x, y) REAL_MUL_ASM(x, y, 15 + 30 - REAL_RADIX)

# else

# define REAL_MUL(x, y) (((dreal)(x) * (dreal)(y)) >> REAL_RADIX)

# define REAL_MUL_15(x, y) (((dreal)(x) * (dreal)(y)) >> 15)

# define REAL_MUL_SCALE_LAYER12(x, y) (((dreal)(x) * (dreal)(y)) >> (15 + 30 - REAL_RADIX))

# endif

# ifdef REAL_MUL_SCALE_LAYER3_ASM

# define REAL_MUL_SCALE_LAYER3(x, y, z) REAL_MUL_SCALE_LAYER3_ASM(x, y, 13 + gainpow2_scale[z] - REAL_RADIX)

# else

# define REAL_MUL_SCALE_LAYER3(x, y, z) (((dreal)(x) * (dreal)(y)) >> (13 + gainpow2_scale[z] - REAL_RADIX))

# endif

# define REAL_SCALE_LAYER12(x) ((real)((x) >> (30 - REAL_RADIX)))

# define REAL_SCALE_LAYER3(x, y) ((real)((x) >> (gainpow2_scale[y] - REAL_RADIX)))

# ifdef ACCURATE_ROUNDING

# define REAL_MUL_SYNTH(x, y) REAL_MUL(x, y)

# define REAL_SCALE_DCT64(x) (x)

# define REAL_SCALE_WINDOW(x) (x)

# else

# define REAL_MUL_SYNTH(x, y) ((x) * (y))

# define REAL_SCALE_DCT64(x) ((x) >> 8)

# define REAL_SCALE_WINDOW(x) scale_rounded(x, 16)

# endif

#else

/* Just define a symbol to make things clear.

Existing code still uses (not (float or fixed)) for that. */

# define REAL_IS_DOUBLE

# define real double

#endif

#ifndef REAL_IS_FIXED

# if (defined SIZEOF_INT32_T) && (SIZEOF_INT32_T != 4)

# error "Bad 32bit types!!!"

# endif

#endif

#ifndef DOUBLE_TO_REAL

# define DOUBLE_TO_REAL(x) (real)(x)

#endif

#ifndef DOUBLE_TO_REAL_15

# define DOUBLE_TO_REAL_15(x) (real)(x)

#endif

#ifndef DOUBLE_TO_REAL_POW43

# define DOUBLE_TO_REAL_POW43(x) (real)(x)

#endif

#ifndef DOUBLE_TO_REAL_SCALE_LAYER12

# define DOUBLE_TO_REAL_SCALE_LAYER12(x) (real)(x)

#endif

#ifndef DOUBLE_TO_REAL_SCALE_LAYER3

# define DOUBLE_TO_REAL_SCALE_LAYER3(x, y) (real)(x)

#endif

#ifndef REAL_TO_DOUBLE

# define REAL_TO_DOUBLE(x) (x)

#endif

#ifndef REAL_MUL

# define REAL_MUL(x, y) ((x) * (y))

#endif

#ifndef REAL_MUL_SYNTH

# define REAL_MUL_SYNTH(x, y) ((x) * (y))

#endif

#ifndef REAL_MUL_15

# define REAL_MUL_15(x, y) ((x) * (y))

#endif

#ifndef REAL_MUL_SCALE_LAYER12

# define REAL_MUL_SCALE_LAYER12(x, y) ((x) * (y))

#endif

#ifndef REAL_MUL_SCALE_LAYER3

# define REAL_MUL_SCALE_LAYER3(x, y, z) ((x) * (y))

#endif

#ifndef REAL_SCALE_LAYER12

# define REAL_SCALE_LAYER12(x) (x)

#endif

#ifndef REAL_SCALE_LAYER3

# define REAL_SCALE_LAYER3(x, y) (x)

#endif

#ifndef REAL_SCALE_DCT64

# define REAL_SCALE_DCT64(x) (x)

#endif

/* used to be: AUDIOBUFSIZE = n*64 with n=1,2,3 ...

now: factor on minimum frame buffer size (which takes upsampling into account) */

#define AUDIOBUFSIZE 2

#include "true.h"

#define MAX_NAME_SIZE 81

#define SBLIMIT 32

#define SCALE_BLOCK 12

#define SSLIMIT 18

/* Same as MPG_M_* */

#define MPG_MD_STEREO 0

#define MPG_MD_JOINT_STEREO 1

#define MPG_MD_DUAL_CHANNEL 2

#define MPG_MD_MONO 3

/* We support short or float output samples...

Short integer amplitude is scaled by this. */

#define SHORT_SCALE 32768

/* That scales a short-scaled value to a 32bit integer scaled one

value = 2**31/2**15 */

#define S32_RESCALE 65536

/* Pre Shift fo 16 to 8 bit converter table */

#define AUSHIFT (3)

#include "optimize.h"

#include "decode.h"

#include "parse.h"

#include "frame.h"

/* fr is a mpg123_handle* by convention here... */

#if !defined(LIBMPG123_QUIET) || defined(DEBUG)

#define NOQUIET (!(fr->p.flags & MPG123_QUIET))

#define VERBOSE (NOQUIET && fr->p.verbose)

#define VERBOSE2 (NOQUIET && fr->p.verbose > 1)

#define VERBOSE3 (NOQUIET && fr->p.verbose > 2)

#define VERBOSE4 (NOQUIET && fr->p.verbose > 3)

#define PVERB(mp, level) (!((mp)->flags & MPG123_QUIET) && (mp)->verbose >= (level))

#else

#define NOQUIET 0

#define VERBOSE 0

#define VERBOSE2 0

#define VERBOSE3 0

#define VERBOSE4 0

#define PVERB(mp, level) 0

#endif

int decode_update(mpg123_handle *mh);

/* residing in format.c */

off_t decoder_synth_bytes(mpg123_handle *fr , off_t s);

off_t samples_to_bytes(mpg123_handle *fr , off_t s);

off_t bytes_to_samples(mpg123_handle *fr , off_t b);

off_t outblock_bytes(mpg123_handle *fr, off_t s);

/* Postprocessing format conversion of freshly decoded buffer. */

void postprocess_buffer(mpg123_handle *fr);

/* If networking is enabled and we really mean internal networking, the timeout_read function is available. */

#if defined (NETWORK) && !defined (WANT_WIN32_SOCKETS)

/* Does not work with win32 */

#define TIMEOUT_READ

#endif

#if defined(__OS2__) && !defined(__EMX__)

#undef TIMEOUT_READ

#endif

#endif