Rev 1905 | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1905 | serge | 1 | /* |
| 2 | mpg123lib_intern: Common non-public stuff for libmpg123 |
||
| 3 | |||
| 4 | copyright 1995-2008 by the mpg123 project - free software under the terms of the LGPL 2.1 |
||
| 5 | see COPYING and AUTHORS files in distribution or http://mpg123.org |
||
| 6 | |||
| 7 | derived from the old mpg123.h |
||
| 8 | */ |
||
| 9 | |||
| 10 | #ifndef MPG123_H_INTERN |
||
| 11 | #define MPG123_H_INTERN |
||
| 12 | |||
| 13 | #define MPG123_RATES 9 |
||
| 3960 | Serge | 14 | #define MPG123_ENCODINGS 12 |
| 1905 | serge | 15 | |
| 16 | #include "config.h" /* Load this before _anything_ */ |
||
| 3960 | Serge | 17 | #include "intsym.h" /* Prefixing of internal symbols that still are public in a static lib. */ |
| 1905 | serge | 18 | |
| 19 | /* ABI conformance for other compilers. |
||
| 20 | mpg123 needs 16byte-aligned stack for SSE and friends. |
||
| 21 | gcc provides that, but others don't necessarily. */ |
||
| 22 | #ifdef ABI_ALIGN_FUN |
||
| 23 | #ifndef attribute_align_arg |
||
| 24 | #if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__>1) |
||
| 25 | # define attribute_align_arg __attribute__((force_align_arg_pointer)) |
||
| 26 | /* The gcc that can align the stack does not need the check... nor does it work with gcc 4.3+, anyway. */ |
||
| 27 | #else |
||
| 3960 | Serge | 28 | |
| 1905 | serge | 29 | # define attribute_align_arg |
| 3960 | Serge | 30 | /* Other compilers get code to catch misaligned stack. |
| 31 | Well, except Sun Studio, which accepts the aligned attribute but does not honor it. */ |
||
| 32 | #if !defined(__SUNPRO_C) |
||
| 33 | # define NEED_ALIGNCHECK |
||
| 1905 | serge | 34 | #endif |
| 3960 | Serge | 35 | |
| 1905 | serge | 36 | #endif |
| 3960 | Serge | 37 | #endif |
| 1905 | serge | 38 | #else |
| 39 | #define attribute_align_arg |
||
| 40 | /* We won't try the align check... */ |
||
| 41 | #endif |
||
| 42 | |||
| 43 | /* export DLL symbols */ |
||
| 44 | #if defined(WIN32) && defined(DYNAMIC_BUILD) |
||
| 45 | #define BUILD_MPG123_DLL |
||
| 46 | #endif |
||
| 47 | #include "compat.h" |
||
| 48 | #include "mpg123.h" |
||
| 49 | |||
| 50 | #define SKIP_JUNK 1 |
||
| 51 | |||
| 52 | #ifndef M_PI |
||
| 53 | # define M_PI 3.14159265358979323846 |
||
| 54 | #endif |
||
| 55 | #ifndef M_SQRT2 |
||
| 56 | # define M_SQRT2 1.41421356237309504880 |
||
| 57 | #endif |
||
| 58 | |||
| 59 | #ifdef SUNOS |
||
| 60 | #define memmove(dst,src,size) bcopy(src,dst,size) |
||
| 61 | #endif |
||
| 62 | |||
| 63 | /* some stuff has to go back to mpg123.h */ |
||
| 64 | #ifdef REAL_IS_FLOAT |
||
| 65 | # define real float |
||
| 66 | # define REAL_SCANF "%f" |
||
| 67 | # define REAL_PRINTF "%f" |
||
| 68 | #elif defined(REAL_IS_LONG_DOUBLE) |
||
| 69 | # define real long double |
||
| 70 | # define REAL_SCANF "%Lf" |
||
| 71 | # define REAL_PRINTF "%Lf" |
||
| 72 | #elif defined(REAL_IS_FIXED) |
||
| 73 | /* Disable some output formats for fixed point decoder... */ |
||
| 74 | |||
| 75 | # define real long |
||
| 76 | |||
| 77 | /* |
||
| 78 | for fixed-point decoders, use pre-calculated tables to avoid expensive floating-point maths |
||
| 79 | undef this macro for run-time calculation |
||
| 80 | */ |
||
| 81 | #define PRECALC_TABLES |
||
| 82 | |||
| 83 | # define REAL_RADIX 24 |
||
| 84 | # define REAL_FACTOR 16777216.0 |
||
| 85 | |||
| 86 | static inline long double_to_long_rounded(double x, double scalefac) |
||
| 87 | { |
||
| 88 | x *= scalefac; |
||
| 89 | x += (x > 0) ? 0.5 : -0.5; |
||
| 90 | return (long)x; |
||
| 91 | } |
||
| 92 | |||
| 93 | static inline long scale_rounded(long x, int shift) |
||
| 94 | { |
||
| 95 | x += (x >> 31); |
||
| 96 | x >>= (shift - 1); |
||
| 97 | x += (x & 1); |
||
| 98 | return (x >> 1); |
||
| 99 | } |
||
| 100 | |||
| 101 | # ifdef __GNUC__ |
||
| 102 | # if defined(OPT_I386) |
||
| 103 | /* for i386_nofpu decoder */ |
||
| 104 | # define REAL_MUL_ASM(x, y, radix) \ |
||
| 105 | ({ \ |
||
| 106 | long _x=(x), _y=(y); \ |
||
| 107 | __asm__ ( \ |
||
| 108 | "imull %1 \n\t" \ |
||
| 109 | "shrdl %2, %%edx, %0 \n\t" \ |
||
| 110 | : "+&a" (_x) \ |
||
| 111 | : "mr" (_y), "I" (radix) \ |
||
| 112 | : "%edx", "cc" \ |
||
| 113 | ); \ |
||
| 114 | _x; \ |
||
| 115 | }) |
||
| 116 | |||
| 117 | # define REAL_MUL_SCALE_LAYER3_ASM(x, y, radix) \ |
||
| 118 | ({ \ |
||
| 119 | long _x=(x), _y=(y), _radix=(radix); \ |
||
| 120 | __asm__ ( \ |
||
| 121 | "imull %1 \n\t" \ |
||
| 122 | "shrdl %%cl, %%edx, %0 \n\t" \ |
||
| 123 | : "+&a" (_x) \ |
||
| 124 | : "mr" (_y), "c" (_radix) \ |
||
| 125 | : "%edx", "cc" \ |
||
| 126 | ); \ |
||
| 127 | _x; \ |
||
| 128 | }) |
||
| 129 | # elif defined(OPT_PPC) |
||
| 130 | /* for powerpc */ |
||
| 131 | # define REAL_MUL_ASM(x, y, radix) \ |
||
| 132 | ({ \ |
||
| 133 | long _x=(x), _y=(y), _mull, _mulh; \ |
||
| 134 | __asm__ ( \ |
||
| 135 | "mullw %0, %2, %3 \n\t" \ |
||
| 136 | "mulhw %1, %2, %3 \n\t" \ |
||
| 137 | "srwi %0, %0, %4 \n\t" \ |
||
| 138 | "rlwimi %0, %1, %5, 0, %6 \n\t" \ |
||
| 139 | : "=&r" (_mull), "=&r" (_mulh) \ |
||
| 3960 | Serge | 140 | : "r" (_x), "r" (_y), "i" (radix), "i" (32-(radix)), "i" ((radix)-1) \ |
| 1905 | serge | 141 | ); \ |
| 142 | _mull; \ |
||
| 143 | }) |
||
| 144 | |||
| 145 | # define REAL_MUL_SCALE_LAYER3_ASM(x, y, radix) \ |
||
| 146 | ({ \ |
||
| 147 | long _x=(x), _y=(y), _radix=(radix), _mull, _mulh, _radix2; \ |
||
| 148 | __asm__ ( \ |
||
| 149 | "mullw %0, %3, %4 \n\t" \ |
||
| 150 | "mulhw %1, %3, %4 \n\t" \ |
||
| 151 | "subfic %2, %5, 32 \n\t" \ |
||
| 152 | "srw %0, %0, %5 \n\t" \ |
||
| 153 | "slw %1, %1, %2 \n\t" \ |
||
| 154 | "or %0, %0, %1 \n\t" \ |
||
| 155 | : "=&r" (_mull), "=&r" (_mulh), "=&r" (_radix2) \ |
||
| 3960 | Serge | 156 | : "r" (_x), "r" (_y), "r" (_radix) \ |
| 1905 | serge | 157 | : "cc" \ |
| 158 | ); \ |
||
| 159 | _mull; \ |
||
| 160 | }) |
||
| 161 | # elif defined(OPT_ARM) |
||
| 162 | /* for arm */ |
||
| 163 | # define REAL_MUL_ASM(x, y, radix) \ |
||
| 164 | ({ \ |
||
| 165 | long _x=(x), _y=(y), _mull, _mulh; \ |
||
| 166 | __asm__ ( \ |
||
| 167 | "smull %0, %1, %2, %3 \n\t" \ |
||
| 168 | "mov %0, %0, lsr %4 \n\t" \ |
||
| 169 | "orr %0, %0, %1, lsl %5 \n\t" \ |
||
| 170 | : "=&r" (_mull), "=&r" (_mulh) \ |
||
| 3960 | Serge | 171 | : "r" (_x), "r" (_y), "M" (radix), "M" (32-(radix)) \ |
| 1905 | serge | 172 | ); \ |
| 173 | _mull; \ |
||
| 174 | }) |
||
| 175 | |||
| 176 | # define REAL_MUL_SCALE_LAYER3_ASM(x, y, radix) \ |
||
| 177 | ({ \ |
||
| 178 | long _x=(x), _y=(y), _radix=(radix), _mull, _mulh, _radix2; \ |
||
| 179 | __asm__ ( \ |
||
| 180 | "smull %0, %1, %3, %4 \n\t" \ |
||
| 181 | "mov %0, %0, lsr %5 \n\t" \ |
||
| 182 | "rsb %2, %5, #32 \n\t" \ |
||
| 3960 | Serge | 183 | "mov %1, %1, lsl %2 \n\t" \ |
| 184 | "orr %0, %0, %1 \n\t" \ |
||
| 1905 | serge | 185 | : "=&r" (_mull), "=&r" (_mulh), "=&r" (_radix2) \ |
| 3960 | Serge | 186 | : "r" (_x), "r" (_y), "r" (_radix) \ |
| 1905 | serge | 187 | ); \ |
| 188 | _mull; \ |
||
| 189 | }) |
||
| 190 | # endif |
||
| 191 | # endif |
||
| 192 | |||
| 193 | /* I just changed the (int) to (long) there... seemed right. */ |
||
| 194 | # define DOUBLE_TO_REAL(x) (double_to_long_rounded(x, REAL_FACTOR)) |
||
| 195 | # define DOUBLE_TO_REAL_15(x) (double_to_long_rounded(x, 32768.0)) |
||
| 196 | # define DOUBLE_TO_REAL_POW43(x) (double_to_long_rounded(x, 8192.0)) |
||
| 197 | # define DOUBLE_TO_REAL_SCALE_LAYER12(x) (double_to_long_rounded(x, 1073741824.0)) |
||
| 198 | # define DOUBLE_TO_REAL_SCALE_LAYER3(x, y) (double_to_long_rounded(x, pow(2.0,gainpow2_scale[y]))) |
||
| 199 | # define REAL_TO_DOUBLE(x) ((double)(x) / REAL_FACTOR) |
||
| 200 | # ifdef REAL_MUL_ASM |
||
| 201 | # define REAL_MUL(x, y) REAL_MUL_ASM(x, y, REAL_RADIX) |
||
| 202 | # define REAL_MUL_15(x, y) REAL_MUL_ASM(x, y, 15) |
||
| 203 | # define REAL_MUL_SCALE_LAYER12(x, y) REAL_MUL_ASM(x, y, 15 + 30 - REAL_RADIX) |
||
| 204 | # else |
||
| 205 | # define REAL_MUL(x, y) (((long long)(x) * (long long)(y)) >> REAL_RADIX) |
||
| 206 | # define REAL_MUL_15(x, y) (((long long)(x) * (long long)(y)) >> 15) |
||
| 207 | # define REAL_MUL_SCALE_LAYER12(x, y) (((long long)(x) * (long long)(y)) >> (15 + 30 - REAL_RADIX)) |
||
| 208 | # endif |
||
| 209 | # ifdef REAL_MUL_SCALE_LAYER3_ASM |
||
| 210 | # define REAL_MUL_SCALE_LAYER3(x, y, z) REAL_MUL_SCALE_LAYER3_ASM(x, y, 13 + gainpow2_scale[z] - REAL_RADIX) |
||
| 211 | # else |
||
| 212 | # define REAL_MUL_SCALE_LAYER3(x, y, z) (((long long)(x) * (long long)(y)) >> (13 + gainpow2_scale[z] - REAL_RADIX)) |
||
| 213 | # endif |
||
| 214 | # define REAL_SCALE_LAYER12(x) ((long)((x) >> (30 - REAL_RADIX))) |
||
| 215 | # define REAL_SCALE_LAYER3(x, y) ((long)((x) >> (gainpow2_scale[y] - REAL_RADIX))) |
||
| 216 | # ifdef ACCURATE_ROUNDING |
||
| 217 | # define REAL_MUL_SYNTH(x, y) REAL_MUL(x, y) |
||
| 218 | # define REAL_SCALE_DCT64(x) (x) |
||
| 219 | # define REAL_SCALE_WINDOW(x) (x) |
||
| 220 | # else |
||
| 221 | # define REAL_MUL_SYNTH(x, y) ((x) * (y)) |
||
| 222 | # define REAL_SCALE_DCT64(x) ((x) >> 8) |
||
| 223 | # define REAL_SCALE_WINDOW(x) scale_rounded(x, 16) |
||
| 224 | # endif |
||
| 225 | # define REAL_SCANF "%ld" |
||
| 226 | # define REAL_PRINTF "%ld" |
||
| 227 | |||
| 228 | #else |
||
| 229 | # define real double |
||
| 230 | # define REAL_SCANF "%lf" |
||
| 231 | # define REAL_PRINTF "%f" |
||
| 232 | #endif |
||
| 233 | |||
| 234 | #ifndef REAL_IS_FIXED |
||
| 235 | # if (defined SIZEOF_INT32_T) && (SIZEOF_INT32_T != 4) |
||
| 236 | # error "Bad 32bit types!!!" |
||
| 237 | # endif |
||
| 238 | #endif |
||
| 239 | |||
| 240 | #ifndef DOUBLE_TO_REAL |
||
| 241 | # define DOUBLE_TO_REAL(x) (real)(x) |
||
| 242 | #endif |
||
| 243 | #ifndef DOUBLE_TO_REAL_15 |
||
| 244 | # define DOUBLE_TO_REAL_15(x) (real)(x) |
||
| 245 | #endif |
||
| 246 | #ifndef DOUBLE_TO_REAL_POW43 |
||
| 247 | # define DOUBLE_TO_REAL_POW43(x) (real)(x) |
||
| 248 | #endif |
||
| 249 | #ifndef DOUBLE_TO_REAL_SCALE_LAYER12 |
||
| 250 | # define DOUBLE_TO_REAL_SCALE_LAYER12(x) (real)(x) |
||
| 251 | #endif |
||
| 252 | #ifndef DOUBLE_TO_REAL_SCALE_LAYER3 |
||
| 253 | # define DOUBLE_TO_REAL_SCALE_LAYER3(x, y) (real)(x) |
||
| 254 | #endif |
||
| 255 | #ifndef REAL_TO_DOUBLE |
||
| 256 | # define REAL_TO_DOUBLE(x) (x) |
||
| 257 | #endif |
||
| 258 | |||
| 259 | #ifndef REAL_MUL |
||
| 260 | # define REAL_MUL(x, y) ((x) * (y)) |
||
| 261 | #endif |
||
| 262 | #ifndef REAL_MUL_SYNTH |
||
| 263 | # define REAL_MUL_SYNTH(x, y) ((x) * (y)) |
||
| 264 | #endif |
||
| 265 | #ifndef REAL_MUL_15 |
||
| 266 | # define REAL_MUL_15(x, y) ((x) * (y)) |
||
| 267 | #endif |
||
| 268 | #ifndef REAL_MUL_SCALE_LAYER12 |
||
| 269 | # define REAL_MUL_SCALE_LAYER12(x, y) ((x) * (y)) |
||
| 270 | #endif |
||
| 271 | #ifndef REAL_MUL_SCALE_LAYER3 |
||
| 272 | # define REAL_MUL_SCALE_LAYER3(x, y, z) ((x) * (y)) |
||
| 273 | #endif |
||
| 274 | #ifndef REAL_SCALE_LAYER12 |
||
| 275 | # define REAL_SCALE_LAYER12(x) (x) |
||
| 276 | #endif |
||
| 277 | #ifndef REAL_SCALE_LAYER3 |
||
| 278 | # define REAL_SCALE_LAYER3(x, y) (x) |
||
| 279 | #endif |
||
| 280 | #ifndef REAL_SCALE_DCT64 |
||
| 281 | # define REAL_SCALE_DCT64(x) (x) |
||
| 282 | #endif |
||
| 283 | |||
| 284 | /* used to be: AUDIOBUFSIZE = n*64 with n=1,2,3 ... |
||
| 285 | now: factor on minimum frame buffer size (which takes upsampling into account) */ |
||
| 286 | #define AUDIOBUFSIZE 2 |
||
| 287 | |||
| 288 | #include "true.h" |
||
| 289 | |||
| 290 | #define MAX_NAME_SIZE 81 |
||
| 291 | #define SBLIMIT 32 |
||
| 292 | #define SCALE_BLOCK 12 |
||
| 293 | #define SSLIMIT 18 |
||
| 294 | |||
| 295 | /* Same as MPG_M_* */ |
||
| 296 | #define MPG_MD_STEREO 0 |
||
| 297 | #define MPG_MD_JOINT_STEREO 1 |
||
| 298 | #define MPG_MD_DUAL_CHANNEL 2 |
||
| 299 | #define MPG_MD_MONO 3 |
||
| 300 | |||
| 301 | /* We support short or float output samples... |
||
| 302 | Short integer amplitude is scaled by this. */ |
||
| 303 | #define SHORT_SCALE 32768 |
||
| 304 | /* That scales a short-scaled value to a 32bit integer scaled one |
||
| 305 | value = 2**31/2**15 */ |
||
| 306 | #define S32_RESCALE 65536 |
||
| 307 | |||
| 308 | /* Pre Shift fo 16 to 8 bit converter table */ |
||
| 309 | #define AUSHIFT (3) |
||
| 310 | |||
| 311 | #include "optimize.h" |
||
| 312 | #include "decode.h" |
||
| 313 | #include "parse.h" |
||
| 314 | #include "frame.h" |
||
| 315 | |||
| 316 | /* fr is a mpg123_handle* by convention here... */ |
||
| 3960 | Serge | 317 | #define NOQUIET (!(fr->p.flags & MPG123_QUIET)) |
| 1905 | serge | 318 | #define VERBOSE (NOQUIET && fr->p.verbose) |
| 319 | #define VERBOSE2 (NOQUIET && fr->p.verbose > 1) |
||
| 320 | #define VERBOSE3 (NOQUIET && fr->p.verbose > 2) |
||
| 321 | #define VERBOSE4 (NOQUIET && fr->p.verbose > 3) |
||
| 3960 | Serge | 322 | #define PVERB(mp, level) (!((mp)->flags & MPG123_QUIET) && (mp)->verbose >= (level)) |
| 1905 | serge | 323 | |
| 324 | int decode_update(mpg123_handle *mh); |
||
| 325 | /* residing in format.c */ |
||
| 3960 | Serge | 326 | off_t samples_to_storage(mpg123_handle *fr , off_t s); |
| 1905 | serge | 327 | off_t samples_to_bytes(mpg123_handle *fr , off_t s); |
| 328 | off_t bytes_to_samples(mpg123_handle *fr , off_t b); |
||
| 3960 | Serge | 329 | /* Postprocessing format conversion of freshly decoded buffer. */ |
| 330 | void postprocess_buffer(mpg123_handle *fr); |
||
| 1905 | serge | 331 | |
| 3960 | Serge | 332 | /* If networking is enabled and we really mean internal networking, the timeout_read function is available. */ |
| 333 | #if defined (NETWORK) && !defined (WANT_WIN32_SOCKETS) |
||
| 334 | /* Does not work with win32 */ |
||
| 335 | #define TIMEOUT_READ |
||
| 1905 | serge | 336 | #endif |
| 3960 | Serge | 337 | |
| 338 | #endif |