retronetworking
/
freeswitch
13
0
Fork 0
Code Pull Requests Releases Activity
freeswitch/libs/libsndfile/src/common.c

1663 lines
42 KiB
C
Raw Blame History

/*
** Copyright (C) 1999-2013 Erik de Castro Lopo <erikd@mega-nerd.com>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU Lesser General Public License as published by
** the Free Software Foundation; either version 2.1 of the License, or
** (at your option) any later version.
**
** This program 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 Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <config.h>
#include <stdarg.h>
#include <string.h>
#ifndef _MSC_VER
#include <unistd.h>
#endif
#include <ctype.h>
#include <math.h>
#include <time.h>
#ifndef _MSC_VER
#include <sys/time.h>
#endif
#include "sndfile.h"
#include "sfendian.h"
#include "common.h"
/*-----------------------------------------------------------------------------------------------
** psf_log_printf allows libsndfile internal functions to print to an internal parselog which
** can later be displayed.
** The format specifiers are as for printf but without the field width and other modifiers.
** Printing is performed to the parselog char array of the SF_PRIVATE struct.
** Printing is done in such a way as to guarantee that the log never overflows the end of the
** parselog array.
*/
static inline void
log_putchar (SF_PRIVATE *psf, char ch)
{ if (psf->parselog.indx < SIGNED_SIZEOF (psf->parselog.buf) - 1)
{ psf->parselog.buf [psf->parselog.indx++] = ch ;
psf->parselog.buf [psf->parselog.indx] = 0 ;
} ;
return ;
} /* log_putchar */
void
psf_log_printf (SF_PRIVATE *psf, const char *format, ...)
{ va_list ap ;
unsigned int u ;
int d, tens, shift, width, width_specifier, left_align ;
char c, *strptr, istr [5], lead_char, sign_char ;
va_start (ap, format) ;
while ((c = *format++))
{ if (c != '%')
{ log_putchar (psf, c) ;
continue ;
} ;
if (format [0] == '%') /* Handle %% */
{ log_putchar (psf, '%') ;
format ++ ;
continue ;
} ;
sign_char = 0 ;
left_align = SF_FALSE ;
while (1)
{ switch (format [0])
{ case ' ' :
case '+' :
sign_char = format [0] ;
format ++ ;
continue ;
case '-' :
left_align = SF_TRUE ;
format ++ ;
continue ;
default : break ;
} ;
break ;
} ;
if (format [0] == 0)
break ;
lead_char = ' ' ;
if (format [0] == '0')
lead_char = '0' ;
width_specifier = 0 ;
while ((c = *format++) && isdigit (c))
width_specifier = width_specifier * 10 + (c - '0') ;
switch (c)
{ case 0 : /* NULL character. */
va_end (ap) ;
return ;
case 's': /* string */
strptr = va_arg (ap, char *) ;
if (strptr == NULL)
break ;
width_specifier -= strlen (strptr) ;
if (left_align == SF_FALSE)
while (width_specifier -- > 0)
log_putchar (psf, ' ') ;
while (*strptr)
log_putchar (psf, *strptr++) ;
while (width_specifier -- > 0)
log_putchar (psf, ' ') ;
break ;
case 'd': /* int */
d = va_arg (ap, int) ;
if (d < 0)
{ d = -d ;
sign_char = '-' ;
if (lead_char != '0' && left_align == SF_FALSE)
width_specifier -- ;
} ;
tens = 1 ;
width = 1 ;
while (d / tens >= 10)
{ tens *= 10 ;
width ++ ;
} ;
width_specifier -= width ;
if (sign_char == ' ')
{ log_putchar (psf, ' ') ;
width_specifier -- ;
} ;
if (left_align == SF_FALSE && lead_char != '0')
{ if (sign_char == '+')
width_specifier -- ;
while (width_specifier -- > 0)
log_putchar (psf, lead_char) ;
} ;
if (sign_char == '+' || sign_char == '-')
{ log_putchar (psf, sign_char) ;
width_specifier -- ;
} ;
if (left_align == SF_FALSE)
while (width_specifier -- > 0)
log_putchar (psf, lead_char) ;
while (tens > 0)
{ log_putchar (psf, '0' + d / tens) ;
d %= tens ;
tens /= 10 ;
} ;
while (width_specifier -- > 0)
log_putchar (psf, lead_char) ;
break ;
case 'D': /* sf_count_t */
{ sf_count_t D, Tens ;
D = va_arg (ap, sf_count_t) ;
if (D == 0)
{ while (-- width_specifier > 0)
log_putchar (psf, lead_char) ;
log_putchar (psf, '0') ;
break ;
}
if (D < 0)
{ log_putchar (psf, '-') ;
D = -D ;
} ;
Tens = 1 ;
width = 1 ;
while (D / Tens >= 10)
{ Tens *= 10 ;
width ++ ;
} ;
while (width_specifier > width)
{ log_putchar (psf, lead_char) ;
width_specifier-- ;
} ;
while (Tens > 0)
{ log_putchar (psf, '0' + D / Tens) ;
D %= Tens ;
Tens /= 10 ;
} ;
} ;
break ;
case 'u': /* unsigned int */
u = va_arg (ap, unsigned int) ;
tens = 1 ;
width = 1 ;
while (u / tens >= 10)
{ tens *= 10 ;
width ++ ;
} ;
width_specifier -= width ;
if (sign_char == ' ')
{ log_putchar (psf, ' ') ;
width_specifier -- ;
} ;
if (left_align == SF_FALSE && lead_char != '0')
{ if (sign_char == '+')
width_specifier -- ;
while (width_specifier -- > 0)
log_putchar (psf, lead_char) ;
} ;
if (sign_char == '+' || sign_char == '-')
{ log_putchar (psf, sign_char) ;
width_specifier -- ;
} ;
if (left_align == SF_FALSE)
while (width_specifier -- > 0)
log_putchar (psf, lead_char) ;
while (tens > 0)
{ log_putchar (psf, '0' + u / tens) ;
u %= tens ;
tens /= 10 ;
} ;
while (width_specifier -- > 0)
log_putchar (psf, lead_char) ;
break ;
case 'c': /* char */
c = va_arg (ap, int) & 0xFF ;
log_putchar (psf, c) ;
break ;
case 'x': /* hex */
case 'X': /* hex */
d = va_arg (ap, int) ;
if (d == 0)
{ while (--width_specifier > 0)
log_putchar (psf, lead_char) ;
log_putchar (psf, '0') ;
break ;
} ;
shift = 28 ;
width = (width_specifier < 8) ? 8 : width_specifier ;
while (! ((0xF << shift) & d))
{ shift -= 4 ;
width -- ;
} ;
while (width > 0 && width_specifier > width)
{ log_putchar (psf, lead_char) ;
width_specifier-- ;
} ;
while (shift >= 0)
{ c = (d >> shift) & 0xF ;
log_putchar (psf, (c > 9) ? c + 'A' - 10 : c + '0') ;
shift -= 4 ;
} ;
break ;
case 'M': /* int2str */
d = va_arg (ap, int) ;
if (CPU_IS_LITTLE_ENDIAN)
{ istr [0] = d & 0xFF ;
istr [1] = (d >> 8) & 0xFF ;
istr [2] = (d >> 16) & 0xFF ;
istr [3] = (d >> 24) & 0xFF ;
}
else
{ istr [3] = d & 0xFF ;
istr [2] = (d >> 8) & 0xFF ;
istr [1] = (d >> 16) & 0xFF ;
istr [0] = (d >> 24) & 0xFF ;
} ;
istr [4] = 0 ;
strptr = istr ;
while (*strptr)
{ c = *strptr++ ;
log_putchar (psf, c) ;
} ;
break ;
default :
log_putchar (psf, '*') ;
log_putchar (psf, c) ;
log_putchar (psf, '*') ;
break ;
} /* switch */
} /* while */
va_end (ap) ;
return ;
} /* psf_log_printf */
/*-----------------------------------------------------------------------------------------------
** ASCII header printf functions.
** Some formats (ie NIST) use ascii text in their headers.
** Format specifiers are the same as the standard printf specifiers (uses vsnprintf).
** If this generates a compile error on any system, the author should be notified
** so an alternative vsnprintf can be provided.
*/
void
psf_asciiheader_printf (SF_PRIVATE *psf, const char *format, ...)
{ va_list argptr ;
int maxlen ;
char *start ;
maxlen = strlen ((char*) psf->header) ;
start = ((char*) psf->header) + maxlen ;
maxlen = sizeof (psf->header) - maxlen ;
va_start (argptr, format) ;
vsnprintf (start, maxlen, format, argptr) ;
va_end (argptr) ;
/* Make sure the string is properly terminated. */
start [maxlen - 1] = 0 ;
psf->headindex = strlen ((char*) psf->header) ;
return ;
} /* psf_asciiheader_printf */
/*-----------------------------------------------------------------------------------------------
** Binary header writing functions. Returns number of bytes written.
**
** Format specifiers for psf_binheader_writef are as follows
** m - marker - four bytes - no endian manipulation
**
** e - all following numerical values will be little endian
** E - all following numerical values will be big endian
**
** t - all following O types will be truncated to 4 bytes
** T - switch off truncation of all following O types
**
** 1 - single byte value
** 2 - two byte value
** 3 - three byte value
** 4 - four byte value
** 8 - eight byte value (sometimes written as 4 bytes)
**
** s - string preceded by a four byte length
** S - string including null terminator
** f - floating point data
** d - double precision floating point data
** h - 16 binary bytes value
**
** b - binary data (see below)
** z - zero bytes (ses below)
** j - jump forwards or backwards
**
** To write a word followed by an int (both little endian) use:
** psf_binheader_writef ("e24", wordval, longval) ;
**
** To write binary data use:
** psf_binheader_writef ("b", &bindata, sizeof (bindata)) ;
**
** To write N zero bytes use:
** NOTE: due to platform issues (ie x86-64) you should cast the
** argument to size_t or ensure the variable type is size_t.
** psf_binheader_writef ("z", N) ;
*/
/* These macros may seem a bit messy but do prevent problems with processors which
** seg. fault when asked to write an int or short to a non-int/short aligned address.
*/
static inline void
header_put_byte (SF_PRIVATE *psf, char x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 1)
psf->header [psf->headindex++] = x ;
} /* header_put_byte */
#if (CPU_IS_BIG_ENDIAN == 1)
static inline void
header_put_marker (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 4)
{ psf->header [psf->headindex++] = (x >> 24) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = x ;
} ;
} /* header_put_marker */
#elif (CPU_IS_LITTLE_ENDIAN == 1)
static inline void
header_put_marker (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 4)
{ psf->header [psf->headindex++] = x ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 24) ;
} ;
} /* header_put_marker */
#else
# error "Cannot determine endian-ness of processor."
#endif
static inline void
header_put_be_short (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 2)
{ psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = x ;
} ;
} /* header_put_be_short */
static inline void
header_put_le_short (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 2)
{ psf->header [psf->headindex++] = x ;
psf->header [psf->headindex++] = (x >> 8) ;
} ;
} /* header_put_le_short */
static inline void
header_put_be_3byte (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 3)
{ psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = x ;
} ;
} /* header_put_be_3byte */
static inline void
header_put_le_3byte (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 3)
{ psf->header [psf->headindex++] = x ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = (x >> 16) ;
} ;
} /* header_put_le_3byte */
static inline void
header_put_be_int (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 4)
{ psf->header [psf->headindex++] = (x >> 24) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = x ;
} ;
} /* header_put_be_int */
static inline void
header_put_le_int (SF_PRIVATE *psf, int x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 4)
{ psf->header [psf->headindex++] = x ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 24) ;
} ;
} /* header_put_le_int */
#if (SIZEOF_SF_COUNT_T == 4)
static inline void
header_put_be_8byte (SF_PRIVATE *psf, sf_count_t x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 8)
{ psf->header [psf->headindex++] = 0 ;
psf->header [psf->headindex++] = 0 ;
psf->header [psf->headindex++] = 0 ;
psf->header [psf->headindex++] = 0 ;
psf->header [psf->headindex++] = (x >> 24) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = x ;
} ;
} /* header_put_be_8byte */
static inline void
header_put_le_8byte (SF_PRIVATE *psf, sf_count_t x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 8)
{ psf->header [psf->headindex++] = x ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 24) ;
psf->header [psf->headindex++] = 0 ;
psf->header [psf->headindex++] = 0 ;
psf->header [psf->headindex++] = 0 ;
psf->header [psf->headindex++] = 0 ;
} ;
} /* header_put_le_8byte */
#elif (SIZEOF_SF_COUNT_T == 8)
static inline void
header_put_be_8byte (SF_PRIVATE *psf, sf_count_t x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 8)
{ psf->header [psf->headindex++] = (x >> 56) ;
psf->header [psf->headindex++] = (x >> 48) ;
psf->header [psf->headindex++] = (x >> 40) ;
psf->header [psf->headindex++] = (x >> 32) ;
psf->header [psf->headindex++] = (x >> 24) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = x ;
} ;
} /* header_put_be_8byte */
static inline void
header_put_le_8byte (SF_PRIVATE *psf, sf_count_t x)
{ if (psf->headindex < SIGNED_SIZEOF (psf->header) - 8)
{ psf->header [psf->headindex++] = x ;
psf->header [psf->headindex++] = (x >> 8) ;
psf->header [psf->headindex++] = (x >> 16) ;
psf->header [psf->headindex++] = (x >> 24) ;
psf->header [psf->headindex++] = (x >> 32) ;
psf->header [psf->headindex++] = (x >> 40) ;
psf->header [psf->headindex++] = (x >> 48) ;
psf->header [psf->headindex++] = (x >> 56) ;
} ;
} /* header_put_le_8byte */
#else
#error "SIZEOF_SF_COUNT_T is not defined."
#endif
int
psf_binheader_writef (SF_PRIVATE *psf, const char *format, ...)
{ va_list argptr ;
sf_count_t countdata ;
unsigned long longdata ;
unsigned int data ;
float floatdata ;
double doubledata ;
void *bindata ;
size_t size ;
char c, *strptr ;
int count = 0, trunc_8to4 ;
trunc_8to4 = SF_FALSE ;
va_start (argptr, format) ;
while ((c = *format++))
{ switch (c)
{ case ' ' : /* Do nothing. Just used to space out format string. */
break ;
case 'e' : /* All conversions are now from LE to host. */
psf->rwf_endian = SF_ENDIAN_LITTLE ;
break ;
case 'E' : /* All conversions are now from BE to host. */
psf->rwf_endian = SF_ENDIAN_BIG ;
break ;
case 't' : /* All 8 byte values now get written as 4 bytes. */
trunc_8to4 = SF_TRUE ;
break ;
case 'T' : /* All 8 byte values now get written as 8 bytes. */
trunc_8to4 = SF_FALSE ;
break ;
case 'm' :
data = va_arg (argptr, unsigned int) ;
header_put_marker (psf, data) ;
count += 4 ;
break ;
case '1' :
data = va_arg (argptr, unsigned int) ;
header_put_byte (psf, data) ;
count += 1 ;
break ;
case '2' :
data = va_arg (argptr, unsigned int) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
{ header_put_be_short (psf, data) ;
}
else
{ header_put_le_short (psf, data) ;
} ;
count += 2 ;
break ;
case '3' : /* tribyte */
data = va_arg (argptr, unsigned int) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
{ header_put_be_3byte (psf, data) ;
}
else
{ header_put_le_3byte (psf, data) ;
} ;
count += 3 ;
break ;
case '4' :
data = va_arg (argptr, unsigned int) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
{ header_put_be_int (psf, data) ;
}
else
{ header_put_le_int (psf, data) ;
} ;
count += 4 ;
break ;
case '8' :
countdata = va_arg (argptr, sf_count_t) ;
if (psf->rwf_endian == SF_ENDIAN_BIG && trunc_8to4 == SF_FALSE)
{ header_put_be_8byte (psf, countdata) ;
count += 8 ;
}
else if (psf->rwf_endian == SF_ENDIAN_LITTLE && trunc_8to4 == SF_FALSE)
{ header_put_le_8byte (psf, countdata) ;
count += 8 ;
}
else if (psf->rwf_endian == SF_ENDIAN_BIG && trunc_8to4 == SF_TRUE)
{ longdata = countdata & 0xFFFFFFFF ;
header_put_be_int (psf, longdata) ;
count += 4 ;
}
else if (psf->rwf_endian == SF_ENDIAN_LITTLE && trunc_8to4 == SF_TRUE)
{ longdata = countdata & 0xFFFFFFFF ;
header_put_le_int (psf, longdata) ;
count += 4 ;
}
break ;
case 'f' :
/* Floats are passed as doubles. Is this always true? */
floatdata = (float) va_arg (argptr, double) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
float32_be_write (floatdata, psf->header + psf->headindex) ;
else
float32_le_write (floatdata, psf->header + psf->headindex) ;
psf->headindex += 4 ;
count += 4 ;
break ;
case 'd' :
doubledata = va_arg (argptr, double) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
double64_be_write (doubledata, psf->header + psf->headindex) ;
else
double64_le_write (doubledata, psf->header + psf->headindex) ;
psf->headindex += 8 ;
count += 8 ;
break ;
case 's' :
/* Write a C string (guaranteed to have a zero terminator). */
strptr = va_arg (argptr, char *) ;
size = strlen (strptr) + 1 ;
size += (size & 1) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
header_put_be_int (psf, size) ;
else
header_put_le_int (psf, size) ;
memcpy (&(psf->header [psf->headindex]), strptr, size) ;
psf->headindex += size ;
psf->header [psf->headindex - 1] = 0 ;
count += 4 + size ;
break ;
case 'S' :
/*
** Write an AIFF style string (no zero terminator but possibly
** an extra pad byte if the string length is odd).
*/
strptr = va_arg (argptr, char *) ;
size = strlen (strptr) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
header_put_be_int (psf, size) ;
else
header_put_le_int (psf, size) ;
memcpy (&(psf->header [psf->headindex]), strptr, size + 1) ;
size += (size & 1) ;
psf->headindex += size ;
psf->header [psf->headindex] = 0 ;
count += 4 + size ;
break ;
case 'b' :
bindata = va_arg (argptr, void *) ;
size = va_arg (argptr, size_t) ;
memcpy (&(psf->header [psf->headindex]), bindata, size) ;
psf->headindex += size ;
count += size ;
break ;
case 'z' :
size = va_arg (argptr, size_t) ;
count += size ;
while (size)
{ psf->header [psf->headindex] = 0 ;
psf->headindex ++ ;
size -- ;
} ;
break ;
case 'h' :
bindata = va_arg (argptr, void *) ;
memcpy (&(psf->header [psf->headindex]), bindata, 16) ;
psf->headindex += 16 ;
count += 16 ;
break ;
case 'j' :
size = va_arg (argptr, size_t) ;
psf->headindex += size ;
count = size ;
break ;
default :
psf_log_printf (psf, "*** Invalid format specifier `%c'\n", c) ;
psf->error = SFE_INTERNAL ;
break ;
} ;
} ;
va_end (argptr) ;
return count ;
} /* psf_binheader_writef */
/*-----------------------------------------------------------------------------------------------
** Binary header reading functions. Returns number of bytes read.
**
** Format specifiers are the same as for header write function above with the following
** additions:
**
** p - jump a given number of position from start of file.
**
** If format is NULL, psf_binheader_readf returns the current offset.
*/
#if (CPU_IS_BIG_ENDIAN == 1)
#define GET_MARKER(ptr) ( ((ptr) [0] << 24) | ((ptr) [1] << 16) | \
((ptr) [2] << 8) | ((ptr) [3]))
#elif (CPU_IS_LITTLE_ENDIAN == 1)
#define GET_MARKER(ptr) ( ((ptr) [0]) | ((ptr) [1] << 8) | \
((ptr) [2] << 16) | ((ptr) [3] << 24))
#else
# error "Cannot determine endian-ness of processor."
#endif
#define GET_LE_SHORT(ptr) (((ptr) [1] << 8) | ((ptr) [0]))
#define GET_BE_SHORT(ptr) (((ptr) [0] << 8) | ((ptr) [1]))
#define GET_LE_3BYTE(ptr) ( ((ptr) [2] << 16) | ((ptr) [1] << 8) | ((ptr) [0]))
#define GET_BE_3BYTE(ptr) ( ((ptr) [0] << 16) | ((ptr) [1] << 8) | ((ptr) [2]))
#define GET_LE_INT(ptr) ( ((ptr) [3] << 24) | ((ptr) [2] << 16) | \
((ptr) [1] << 8) | ((ptr) [0]))
#define GET_BE_INT(ptr) ( ((ptr) [0] << 24) | ((ptr) [1] << 16) | \
((ptr) [2] << 8) | ((ptr) [3]))
#define GET_LE_8BYTE(ptr) ( (((sf_count_t) (ptr) [7]) << 56) | (((sf_count_t) (ptr) [6]) << 48) | \
(((sf_count_t) (ptr) [5]) << 40) | (((sf_count_t) (ptr) [4]) << 32) | \
(((sf_count_t) (ptr) [3]) << 24) | (((sf_count_t) (ptr) [2]) << 16) | \
(((sf_count_t) (ptr) [1]) << 8) | ((ptr) [0]))
#define GET_BE_8BYTE(ptr) ( (((sf_count_t) (ptr) [0]) << 56) | (((sf_count_t) (ptr) [1]) << 48) | \
(((sf_count_t) (ptr) [2]) << 40) | (((sf_count_t) (ptr) [3]) << 32) | \
(((sf_count_t) (ptr) [4]) << 24) | (((sf_count_t) (ptr) [5]) << 16) | \
(((sf_count_t) (ptr) [6]) << 8) | ((ptr) [7]))
static int
header_read (SF_PRIVATE *psf, void *ptr, int bytes)
{ int count = 0 ;
if (psf->headindex >= SIGNED_SIZEOF (psf->header))
{ memset (ptr, 0, SIGNED_SIZEOF (psf->header) - psf->headindex) ;
/* This is the best that we can do. */
psf_fseek (psf, bytes, SEEK_CUR) ;
return bytes ;
} ;
if (psf->headindex + bytes > SIGNED_SIZEOF (psf->header))
{ int most ;
most = SIGNED_SIZEOF (psf->header) - psf->headindex ;
psf_fread (psf->header + psf->headend, 1, most, psf) ;
memset ((char *) ptr + most, 0, bytes - most) ;
psf_fseek (psf, bytes - most, SEEK_CUR) ;
return bytes ;
} ;
if (psf->headindex + bytes > psf->headend)
{ count = psf_fread (psf->header + psf->headend, 1, bytes - (psf->headend - psf->headindex), psf) ;
if (count != bytes - (int) (psf->headend - psf->headindex))
{ psf_log_printf (psf, "Error : psf_fread returned short count.\n") ;
return 0 ;
} ;
psf->headend += count ;
} ;
memcpy (ptr, psf->header + psf->headindex, bytes) ;
psf->headindex += bytes ;
return bytes ;
} /* header_read */
static void
header_seek (SF_PRIVATE *psf, sf_count_t position, int whence)
{
switch (whence)
{ case SEEK_SET :
if (position > SIGNED_SIZEOF (psf->header))
{ /* Too much header to cache so just seek instead. */
psf_fseek (psf, position, whence) ;
return ;
} ;
if (position > psf->headend)
psf->headend += psf_fread (psf->header + psf->headend, 1, position - psf->headend, psf) ;
psf->headindex = position ;
break ;
case SEEK_CUR :
if (psf->headindex + position < 0)
break ;
if (psf->headindex >= SIGNED_SIZEOF (psf->header))
{ psf_fseek (psf, position, whence) ;
return ;
} ;
if (psf->headindex + position <= psf->headend)
{ psf->headindex += position ;
break ;
} ;
if (psf->headindex + position > SIGNED_SIZEOF (psf->header))
{ /* Need to jump this without caching it. */
psf->headindex = psf->headend ;
psf_fseek (psf, position, SEEK_CUR) ;
break ;
} ;
psf->headend += psf_fread (psf->header + psf->headend, 1, position - (psf->headend - psf->headindex), psf) ;
psf->headindex = psf->headend ;
break ;
case SEEK_END :
default :
psf_log_printf (psf, "Bad whence param in header_seek().\n") ;
break ;
} ;
return ;
} /* header_seek */
static int
header_gets (SF_PRIVATE *psf, char *ptr, int bufsize)
{
int k ;
for (k = 0 ; k < bufsize - 1 ; k++)
{ if (psf->headindex < psf->headend)
{ ptr [k] = psf->header [psf->headindex] ;
psf->headindex ++ ;
}
else
{ psf->headend += psf_fread (psf->header + psf->headend, 1, 1, psf) ;
ptr [k] = psf->header [psf->headindex] ;
psf->headindex = psf->headend ;
} ;
if (ptr [k] == '\n')
break ;
} ;
ptr [k] = 0 ;
return k ;
} /* header_gets */
int
psf_binheader_readf (SF_PRIVATE *psf, char const *format, ...)
{ va_list argptr ;
sf_count_t *countptr, countdata ;
unsigned char *ucptr, sixteen_bytes [16] ;
unsigned int *intptr, intdata ;
unsigned short *shortptr ;
char *charptr ;
float *floatptr ;
double *doubleptr ;
char c ;
int byte_count = 0, count ;
if (! format)
return psf_ftell (psf) ;
va_start (argptr, format) ;
while ((c = *format++))
{ switch (c)
{ case 'e' : /* All conversions are now from LE to host. */
psf->rwf_endian = SF_ENDIAN_LITTLE ;
break ;
case 'E' : /* All conversions are now from BE to host. */
psf->rwf_endian = SF_ENDIAN_BIG ;
break ;
case 'm' :
intptr = va_arg (argptr, unsigned int*) ;
ucptr = (unsigned char*) intptr ;
byte_count += header_read (psf, ucptr, sizeof (int)) ;
*intptr = GET_MARKER (ucptr) ;
break ;
case 'h' :
intptr = va_arg (argptr, unsigned int*) ;
ucptr = (unsigned char*) intptr ;
byte_count += header_read (psf, sixteen_bytes, sizeof (sixteen_bytes)) ;
{ int k ;
intdata = 0 ;
for (k = 0 ; k < 16 ; k++)
intdata ^= sixteen_bytes [k] << k ;
}
*intptr = intdata ;
break ;
case '1' :
charptr = va_arg (argptr, char*) ;
*charptr = 0 ;
byte_count += header_read (psf, charptr, sizeof (char)) ;
break ;
case '2' :
shortptr = va_arg (argptr, unsigned short*) ;
*shortptr = 0 ;
ucptr = (unsigned char*) shortptr ;
byte_count += header_read (psf, ucptr, sizeof (short)) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
*shortptr = GET_BE_SHORT (ucptr) ;
else
*shortptr = GET_LE_SHORT (ucptr) ;
break ;
case '3' :
intptr = va_arg (argptr, unsigned int*) ;
*intptr = 0 ;
byte_count += header_read (psf, sixteen_bytes, 3) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
*intptr = GET_BE_3BYTE (sixteen_bytes) ;
else
*intptr = GET_LE_3BYTE (sixteen_bytes) ;
break ;
case '4' :
intptr = va_arg (argptr, unsigned int*) ;
*intptr = 0 ;
ucptr = (unsigned char*) intptr ;
byte_count += header_read (psf, ucptr, sizeof (int)) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
*intptr = GET_BE_INT (ucptr) ;
else
*intptr = GET_LE_INT (ucptr) ;
break ;
case '8' :
countptr = va_arg (argptr, sf_count_t *) ;
*countptr = 0 ;
byte_count += header_read (psf, sixteen_bytes, 8) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
countdata = GET_BE_8BYTE (sixteen_bytes) ;
else
countdata = GET_LE_8BYTE (sixteen_bytes) ;
*countptr = countdata ;
break ;
case 'f' : /* Float conversion */
floatptr = va_arg (argptr, float *) ;
*floatptr = 0.0 ;
byte_count += header_read (psf, floatptr, sizeof (float)) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
*floatptr = float32_be_read ((unsigned char*) floatptr) ;
else
*floatptr = float32_le_read ((unsigned char*) floatptr) ;
break ;
case 'd' : /* double conversion */
doubleptr = va_arg (argptr, double *) ;
*doubleptr = 0.0 ;
byte_count += header_read (psf, doubleptr, sizeof (double)) ;
if (psf->rwf_endian == SF_ENDIAN_BIG)
*doubleptr = double64_be_read ((unsigned char*) doubleptr) ;
else
*doubleptr = double64_le_read ((unsigned char*) doubleptr) ;
break ;
case 's' :
psf_log_printf (psf, "Format conversion 's' not implemented yet.\n") ;
/*
strptr = va_arg (argptr, char *) ;
size = strlen (strptr) + 1 ;
size += (size & 1) ;
longdata = H2LE_32 (size) ;
get_int (psf, longdata) ;
memcpy (&(psf->header [psf->headindex]), strptr, size) ;
psf->headindex += size ;
*/
break ;
case 'b' :
charptr = va_arg (argptr, char*) ;
count = va_arg (argptr, size_t) ;
if (count > 0)
byte_count += header_read (psf, charptr, count) ;
break ;
case 'G' :
charptr = va_arg (argptr, char*) ;
count = va_arg (argptr, size_t) ;
if (count > 0)
byte_count += header_gets (psf, charptr, count) ;
break ;
case 'z' :
psf_log_printf (psf, "Format conversion 'z' not implemented yet.\n") ;
/*
size = va_arg (argptr, size_t) ;
while (size)
{ psf->header [psf->headindex] = 0 ;
psf->headindex ++ ;
size -- ;
} ;
*/
break ;
case 'p' :
/* Get the seek position first. */
count = va_arg (argptr, size_t) ;
header_seek (psf, count, SEEK_SET) ;
byte_count = count ;
break ;
case 'j' :
/* Get the seek position first. */
count = va_arg (argptr, size_t) ;
header_seek (psf, count, SEEK_CUR) ;
byte_count += count ;
break ;
default :
psf_log_printf (psf, "*** Invalid format specifier `%c'\n", c) ;
psf->error = SFE_INTERNAL ;
break ;
} ;
} ;
va_end (argptr) ;
return byte_count ;
} /* psf_binheader_readf */
/*-----------------------------------------------------------------------------------------------
*/
sf_count_t
psf_default_seek (SF_PRIVATE *psf, int UNUSED (mode), sf_count_t samples_from_start)
{ sf_count_t position, retval ;
if (! (psf->blockwidth && psf->dataoffset >= 0))
{ psf->error = SFE_BAD_SEEK ;
return PSF_SEEK_ERROR ;
} ;
if (! psf->sf.seekable)
{ psf->error = SFE_NOT_SEEKABLE ;
return PSF_SEEK_ERROR ;
} ;
position = psf->dataoffset + psf->blockwidth * samples_from_start ;
if ((retval = psf_fseek (psf, position, SEEK_SET)) != position)
{ psf->error = SFE_SEEK_FAILED ;
return PSF_SEEK_ERROR ;
} ;
return samples_from_start ;
} /* psf_default_seek */
/*-----------------------------------------------------------------------------------------------
*/
void
psf_hexdump (const void *ptr, int len)
{ const char *data ;
char ascii [17] ;
int k, m ;
if ((data = ptr) == NULL)
return ;
if (len <= 0)
return ;
puts ("") ;
for (k = 0 ; k < len ; k += 16)
{ memset (ascii, ' ', sizeof (ascii)) ;
printf ("%08X: ", k) ;
for (m = 0 ; m < 16 && k + m < len ; m++)
{ printf (m == 8 ? " %02X " : "%02X ", data [k + m] & 0xFF) ;
ascii [m] = psf_isprint (data [k + m]) ? data [k + m] : '.' ;
} ;
if (m <= 8) printf (" ") ;
for ( ; m < 16 ; m++) printf (" ") ;
ascii [16] = 0 ;
printf (" %s\n", ascii) ;
} ;
puts ("") ;
} /* psf_hexdump */
void
psf_log_SF_INFO (SF_PRIVATE *psf)
{ psf_log_printf (psf, "---------------------------------\n") ;
psf_log_printf (psf, " Sample rate : %d\n", psf->sf.samplerate) ;
if (psf->sf.frames == SF_COUNT_MAX)
psf_log_printf (psf, " Frames : unknown\n") ;
else
psf_log_printf (psf, " Frames : %D\n", psf->sf.frames) ;
psf_log_printf (psf, " Channels : %d\n", psf->sf.channels) ;
psf_log_printf (psf, " Format : 0x%X\n", psf->sf.format) ;
psf_log_printf (psf, " Sections : %d\n", psf->sf.sections) ;
psf_log_printf (psf, " Seekable : %s\n", psf->sf.seekable ? "TRUE" : "FALSE") ;
psf_log_printf (psf, "---------------------------------\n") ;
} /* psf_dump_SFINFO */
/*========================================================================================
*/
void*
psf_memset (void *s, int c, sf_count_t len)
{ char *ptr ;
int setcount ;
ptr = (char *) s ;
while (len > 0)
{ setcount = (len > 0x10000000) ? 0x10000000 : (int) len ;
memset (ptr, c, setcount) ;
ptr += setcount ;
len -= setcount ;
} ;
return s ;
} /* psf_memset */
SF_INSTRUMENT *
psf_instrument_alloc (void)
{ SF_INSTRUMENT *instr ;
instr = calloc (1, sizeof (SF_INSTRUMENT)) ;
if (instr == NULL)
return NULL ;
/* Set non-zero default values. */
instr->basenote = -1 ;
instr->velocity_lo = -1 ;
instr->velocity_hi = -1 ;
instr->key_lo = -1 ;
instr->key_hi = -1 ;
return instr ;
} /* psf_instrument_alloc */
void
psf_sanitize_string (char * cptr, int len)
{
do
{
len -- ;
cptr [len] = psf_isprint (cptr [len]) ? cptr [len] : '.' ;
}
while (len > 0) ;
} /* psf_sanitize_string */
void
psf_get_date_str (char *str, int maxlen)
{ time_t current ;
struct tm timedata, *tmptr ;
time (&current) ;
#if defined (HAVE_GMTIME_R)
/* If the re-entrant version is available, use it. */
tmptr = gmtime_r (&current, &timedata) ;
#elif defined (HAVE_GMTIME)
/* Otherwise use the standard one and copy the data to local storage. */
tmptr = gmtime (&current) ;
memcpy (&timedata, tmptr, sizeof (timedata)) ;
#else
tmptr = NULL ;
#endif
if (tmptr)
snprintf (str, maxlen, "%4d-%02d-%02d %02d:%02d:%02d UTC",
1900 + timedata.tm_year, timedata.tm_mon, timedata.tm_mday,
timedata.tm_hour, timedata.tm_min, timedata.tm_sec) ;
else
snprintf (str, maxlen, "Unknown date") ;
return ;
} /* psf_get_date_str */
int
subformat_to_bytewidth (int format)
{
switch (format)
{ case SF_FORMAT_PCM_U8 :
case SF_FORMAT_PCM_S8 :
return 1 ;
case SF_FORMAT_PCM_16 :
return 2 ;
case SF_FORMAT_PCM_24 :
return 3 ;
case SF_FORMAT_PCM_32 :
case SF_FORMAT_FLOAT :
return 4 ;
case SF_FORMAT_DOUBLE :
return 8 ;
} ;
return 0 ;
} /* subformat_to_bytewidth */
int
s_bitwidth_to_subformat (int bits)
{ static int array [] =
{ SF_FORMAT_PCM_S8, SF_FORMAT_PCM_16, SF_FORMAT_PCM_24, SF_FORMAT_PCM_32
} ;
if (bits < 8 || bits > 32)
return 0 ;
return array [((bits + 7) / 8) - 1] ;
} /* bitwidth_to_subformat */
int
u_bitwidth_to_subformat (int bits)
{ static int array [] =
{ SF_FORMAT_PCM_U8, SF_FORMAT_PCM_16, SF_FORMAT_PCM_24, SF_FORMAT_PCM_32
} ;
if (bits < 8 || bits > 32)
return 0 ;
return array [((bits + 7) / 8) - 1] ;
} /* bitwidth_to_subformat */
/*
** psf_rand_int32 : Not crypto quality, but more than adequate for things
** like stream serial numbers in Ogg files or the unique_id field of the
** SF_PRIVATE struct.
*/
int32_t
psf_rand_int32 (void)
{ static int32_t value = -1 ;
int k, count ;
if (value == -1)
{
#if HAVE_GETTIMEOFDAY
struct timeval tv ;
gettimeofday (&tv, NULL) ;
value = tv.tv_sec + tv.tv_usec ;
#else
value = time (NULL) ;
#endif
} ;
count = 4 + (value & 7) ;
for (k = 0 ; k < count ; k++)
value = 11117 * value + 211231 ;
return value ;
} /* psf_rand_int32 */
void
append_snprintf (char * dest, size_t maxlen, const char * fmt, ...)
{ size_t len = strlen (dest) ;
if (len < maxlen)
{ va_list ap ;
va_start (ap, fmt) ;
vsnprintf (dest + len, maxlen - len, fmt, ap) ;
va_end (ap) ;
} ;
return ;
} /* append_snprintf */
void
psf_strlcpy_crlf (char *dest, const char *src, size_t destmax, size_t srcmax)
{ /* Must be minus 2 so it can still expand a single trailing '\n' or '\r'. */
char * destend = dest + destmax - 2 ;
const char * srcend = src + srcmax ;
while (dest < destend && src < srcend)
{ if ((src [0] == '\r' && src [1] == '\n') || (src [0] == '\n' && src [1] == '\r'))
{ *dest++ = '\r' ;
*dest++ = '\n' ;
src += 2 ;
continue ;
} ;
if (src [0] == '\r')
{ *dest++ = '\r' ;
*dest++ = '\n' ;
src += 1 ;
continue ;
} ;
if (src [0] == '\n')
{ *dest++ = '\r' ;
*dest++ = '\n' ;
src += 1 ;
continue ;
} ;
*dest++ = *src++ ;
} ;
/* Make sure dest is terminated. */
*dest = 0 ;
} /* psf_strlcpy_crlf */
sf_count_t
psf_decode_frame_count (SF_PRIVATE *psf)
{ sf_count_t count, readlen, total = 0 ;
BUF_UNION ubuf ;
/* If we're reading from a pipe or the file is too long, just return SF_COUNT_MAX. */
if (psf_is_pipe (psf) || psf->datalength > 0x1000000)
return SF_COUNT_MAX ;
psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
readlen = ARRAY_LEN (ubuf.ibuf) / psf->sf.channels ;
readlen *= psf->sf.channels ;
while ((count = psf->read_int (psf, ubuf.ibuf, readlen)) > 0)
total += count ;
psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
return total / psf->sf.channels ;
} /* psf_decode_frame_count */
/*==============================================================================
*/
#define CASE_NAME(x) case x : return #x ; break ;
const char *
str_of_major_format (int format)
{ switch (SF_CONTAINER (format))
{ CASE_NAME (SF_FORMAT_WAV) ;
CASE_NAME (SF_FORMAT_AIFF) ;
CASE_NAME (SF_FORMAT_AU) ;
CASE_NAME (SF_FORMAT_RAW) ;
CASE_NAME (SF_FORMAT_PAF) ;
CASE_NAME (SF_FORMAT_SVX) ;
CASE_NAME (SF_FORMAT_NIST) ;
CASE_NAME (SF_FORMAT_VOC) ;
CASE_NAME (SF_FORMAT_IRCAM) ;
CASE_NAME (SF_FORMAT_W64) ;
CASE_NAME (SF_FORMAT_MAT4) ;
CASE_NAME (SF_FORMAT_MAT5) ;
CASE_NAME (SF_FORMAT_PVF) ;
CASE_NAME (SF_FORMAT_XI) ;
CASE_NAME (SF_FORMAT_HTK) ;
CASE_NAME (SF_FORMAT_SDS) ;
CASE_NAME (SF_FORMAT_AVR) ;
CASE_NAME (SF_FORMAT_WAVEX) ;
CASE_NAME (SF_FORMAT_SD2) ;
CASE_NAME (SF_FORMAT_FLAC) ;
CASE_NAME (SF_FORMAT_CAF) ;
CASE_NAME (SF_FORMAT_WVE) ;
CASE_NAME (SF_FORMAT_OGG) ;
default :
break ;
} ;
return "BAD_MAJOR_FORMAT" ;
} /* str_of_major_format */
const char *
str_of_minor_format (int format)
{ switch (SF_CODEC (format))
{ CASE_NAME (SF_FORMAT_PCM_S8) ;
CASE_NAME (SF_FORMAT_PCM_16) ;
CASE_NAME (SF_FORMAT_PCM_24) ;
CASE_NAME (SF_FORMAT_PCM_32) ;
CASE_NAME (SF_FORMAT_PCM_U8) ;
CASE_NAME (SF_FORMAT_FLOAT) ;
CASE_NAME (SF_FORMAT_DOUBLE) ;
CASE_NAME (SF_FORMAT_ULAW) ;
CASE_NAME (SF_FORMAT_ALAW) ;
CASE_NAME (SF_FORMAT_IMA_ADPCM) ;
CASE_NAME (SF_FORMAT_MS_ADPCM) ;
CASE_NAME (SF_FORMAT_GSM610) ;
CASE_NAME (SF_FORMAT_VOX_ADPCM) ;
CASE_NAME (SF_FORMAT_G721_32) ;
CASE_NAME (SF_FORMAT_G723_24) ;
CASE_NAME (SF_FORMAT_G723_40) ;
CASE_NAME (SF_FORMAT_DWVW_12) ;
CASE_NAME (SF_FORMAT_DWVW_16) ;
CASE_NAME (SF_FORMAT_DWVW_24) ;
CASE_NAME (SF_FORMAT_DWVW_N) ;
CASE_NAME (SF_FORMAT_DPCM_8) ;
CASE_NAME (SF_FORMAT_DPCM_16) ;
CASE_NAME (SF_FORMAT_VORBIS) ;
default :
break ;
} ;
return "BAD_MINOR_FORMAT" ;
} /* str_of_minor_format */
const char *
str_of_open_mode (int mode)
{ switch (mode)
{ CASE_NAME (SFM_READ) ;
CASE_NAME (SFM_WRITE) ;
CASE_NAME (SFM_RDWR) ;
default :
break ;
} ;
return "BAD_MODE" ;
} /* str_of_open_mode */
const char *
str_of_endianness (int end)
{ switch (end)
{ CASE_NAME (SF_ENDIAN_BIG) ;
CASE_NAME (SF_ENDIAN_LITTLE) ;
CASE_NAME (SF_ENDIAN_CPU) ;
default :
break ;
} ;
/* Zero length string for SF_ENDIAN_FILE. */
return "" ;
} /* str_of_endianness */
/*==============================================================================
*/
void
psf_f2s_array (const float *src, short *dest, int count, int normalize)
{ float normfact ;
normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
while (--count >= 0)
dest [count] = lrintf (src [count] * normfact) ;
return ;
} /* psf_f2s_array */
void
psf_f2s_clip_array (const float *src, short *dest, int count, int normalize)
{ float normfact, scaled_value ;
normfact = normalize ? (1.0 * 0x8000) : 1.0 ;
while (--count >= 0)
{ scaled_value = src [count] * normfact ;
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFF))
{ dest [count] = 0x7FFF ;
continue ;
} ;
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x1000))
{ dest [count] = 0x8000 ;
continue ;
} ;
dest [count] = lrintf (scaled_value) ;
} ;
return ;
} /* psf_f2s_clip_array */
void
psf_d2s_array (const double *src, short *dest, int count, int normalize)
{ double normfact ;
normfact = normalize ? (1.0 * 0x7FFF) : 1.0 ;
while (--count >= 0)
dest [count] = lrint (src [count] * normfact) ;
return ;
} /* psf_f2s_array */
void
psf_d2s_clip_array (const double *src, short *dest, int count, int normalize)
{ double normfact, scaled_value ;
normfact = normalize ? (1.0 * 0x8000) : 1.0 ;
while (--count >= 0)
{ scaled_value = src [count] * normfact ;
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFF))
{ dest [count] = 0x7FFF ;
continue ;
} ;
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x1000))
{ dest [count] = 0x8000 ;
continue ;
} ;
dest [count] = lrint (scaled_value) ;
} ;
return ;
} /* psf_d2s_clip_array */
void
psf_f2i_array (const float *src, int *dest, int count, int normalize)
{ float normfact ;
normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
while (--count >= 0)
dest [count] = lrintf (src [count] * normfact) ;
return ;
} /* psf_f2i_array */
void
psf_f2i_clip_array (const float *src, int *dest, int count, int normalize)
{ float normfact, scaled_value ;
normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
while (--count >= 0)
{ scaled_value = src [count] * normfact ;
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
{ dest [count] = 0x7FFFFFFF ;
continue ;
} ;
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
{ dest [count] = 0x80000000 ;
continue ;
} ;
dest [count] = lrintf (scaled_value) ;
} ;
return ;
} /* psf_f2i_clip_array */
void
psf_d2i_array (const double *src, int *dest, int count, int normalize)
{ double normfact ;
normfact = normalize ? (1.0 * 0x7FFFFFFF) : 1.0 ;
while (--count >= 0)
dest [count] = lrint (src [count] * normfact) ;
return ;
} /* psf_f2i_array */
void
psf_d2i_clip_array (const double *src, int *dest, int count, int normalize)
{ double normfact, scaled_value ;
normfact = normalize ? (8.0 * 0x10000000) : 1.0 ;
while (--count >= 0)
{ scaled_value = src [count] * normfact ;
if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
{ dest [count] = 0x7FFFFFFF ;
continue ;
} ;
if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
{ dest [count] = 0x80000000 ;
continue ;
} ;
dest [count] = lrint (scaled_value) ;
} ;
return ;
} /* psf_d2i_clip_array */
FILE *
psf_open_tmpfile (char * fname, size_t fnamelen)
{ const char * tmpdir ;
FILE * file ;
if (OS_IS_WIN32)
tmpdir = getenv ("TEMP") ;
else
{ tmpdir = getenv ("TMPDIR") ;
tmpdir = tmpdir == NULL ? "/tmp" : tmpdir ;
} ;
// if (tmpdir && access (tmpdir, R_OK | W_OK | X_OK) == 0)
{ snprintf (fname, fnamelen, "%s/%x%x-alac.tmp", tmpdir, psf_rand_int32 (), psf_rand_int32 ()) ;
if ((file = fopen (fname, "wb+")) != NULL)
return file ;
} ;
snprintf (fname, fnamelen, "%x%x-alac.tmp", psf_rand_int32 (), psf_rand_int32 ()) ;
if ((file = fopen (fname, "wb+")) != NULL)
return file ;
memset (fname, 0, fnamelen) ;
return NULL ;
} /* psf_open_tmpfile */
View Git Blame Copy Permalink