mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-03-08 06:50:42 +00:00
a745fc3757
added libraries: opus flac libsndfile updated: libvorbis libogg openal - Everything works as expected for now. Bare in mind libsndfile needed the check for whether or not it could find the xiph libraries removed in order for this to work.
415 lines
12 KiB
C
415 lines
12 KiB
C
/*
|
|
** Copyright (C) 2001-2016 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 "sfconfig.h"
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#include "sndfile.h"
|
|
#include "common.h"
|
|
|
|
static SF_FORMAT_INFO const simple_formats [] =
|
|
{
|
|
{ SF_FORMAT_AIFF | SF_FORMAT_PCM_16,
|
|
"AIFF (Apple/SGI 16 bit PCM)", "aiff"
|
|
},
|
|
|
|
{ SF_FORMAT_AIFF | SF_FORMAT_FLOAT,
|
|
"AIFF (Apple/SGI 32 bit float)", "aifc"
|
|
},
|
|
|
|
{ SF_FORMAT_AIFF | SF_FORMAT_PCM_S8,
|
|
"AIFF (Apple/SGI 8 bit PCM)", "aiff"
|
|
},
|
|
|
|
{ SF_FORMAT_AU | SF_FORMAT_PCM_16,
|
|
"AU (Sun/Next 16 bit PCM)", "au"
|
|
},
|
|
|
|
{ SF_FORMAT_AU | SF_FORMAT_ULAW,
|
|
"AU (Sun/Next 8-bit u-law)", "au"
|
|
},
|
|
|
|
{ SF_FORMAT_CAF | SF_FORMAT_ALAC_16,
|
|
"CAF (Apple 16 bit ALAC)", "caf"
|
|
},
|
|
|
|
{ SF_FORMAT_CAF | SF_FORMAT_PCM_16,
|
|
"CAF (Apple 16 bit PCM)", "caf"
|
|
},
|
|
|
|
#if HAVE_EXTERNAL_XIPH_LIBS
|
|
{ SF_FORMAT_FLAC | SF_FORMAT_PCM_16,
|
|
"FLAC 16 bit", "flac"
|
|
},
|
|
#endif
|
|
|
|
#if HAVE_MPEG
|
|
{ SF_FORMAT_MPEG | SF_FORMAT_MPEG_LAYER_III,
|
|
"MPEG Layer 3", "mp3"
|
|
},
|
|
#endif
|
|
|
|
{ SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM,
|
|
"OKI Dialogic VOX ADPCM", "vox"
|
|
},
|
|
|
|
#if HAVE_EXTERNAL_XIPH_LIBS
|
|
{ SF_FORMAT_OGG | SF_FORMAT_OPUS,
|
|
"Ogg Opus (Xiph Foundation)", "opus"
|
|
},
|
|
|
|
{ SF_FORMAT_OGG | SF_FORMAT_VORBIS,
|
|
"Ogg Vorbis (Xiph Foundation)", "ogg"
|
|
},
|
|
#endif
|
|
|
|
{ SF_FORMAT_WAV | SF_FORMAT_PCM_16,
|
|
"WAV (Microsoft 16 bit PCM)", "wav"
|
|
},
|
|
|
|
{ SF_FORMAT_WAV | SF_FORMAT_FLOAT,
|
|
"WAV (Microsoft 32 bit float)", "wav"
|
|
},
|
|
|
|
{ SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM,
|
|
"WAV (Microsoft 4 bit IMA ADPCM)", "wav"
|
|
},
|
|
|
|
{ SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM,
|
|
"WAV (Microsoft 4 bit MS ADPCM)", "wav"
|
|
},
|
|
|
|
{ SF_FORMAT_WAV | SF_FORMAT_PCM_U8,
|
|
"WAV (Microsoft 8 bit PCM)", "wav"
|
|
},
|
|
|
|
} ; /* simple_formats */
|
|
|
|
int
|
|
psf_get_format_simple_count (void)
|
|
{ return (sizeof (simple_formats) / sizeof (SF_FORMAT_INFO)) ;
|
|
} /* psf_get_format_simple_count */
|
|
|
|
int
|
|
psf_get_format_simple (SF_FORMAT_INFO *data)
|
|
{ int indx ;
|
|
|
|
if (data->format < 0 || data->format >= (SIGNED_SIZEOF (simple_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)))
|
|
return SFE_BAD_COMMAND_PARAM ;
|
|
|
|
indx = data->format ;
|
|
memcpy (data, &(simple_formats [indx]), SIGNED_SIZEOF (SF_FORMAT_INFO)) ;
|
|
|
|
return 0 ;
|
|
} /* psf_get_format_simple */
|
|
|
|
/*============================================================================
|
|
** Major format info.
|
|
*/
|
|
|
|
static SF_FORMAT_INFO const major_formats [] =
|
|
{
|
|
{ SF_FORMAT_AIFF, "AIFF (Apple/SGI)", "aiff" },
|
|
{ SF_FORMAT_AU, "AU (Sun/NeXT)", "au" },
|
|
{ SF_FORMAT_AVR, "AVR (Audio Visual Research)", "avr" },
|
|
{ SF_FORMAT_CAF, "CAF (Apple Core Audio File)", "caf" },
|
|
#if HAVE_EXTERNAL_XIPH_LIBS
|
|
{ SF_FORMAT_FLAC, "FLAC (Free Lossless Audio Codec)", "flac" },
|
|
#endif
|
|
{ SF_FORMAT_HTK, "HTK (HMM Tool Kit)", "htk" },
|
|
{ SF_FORMAT_SVX, "IFF (Amiga IFF/SVX8/SV16)", "iff" },
|
|
{ SF_FORMAT_MAT4, "MAT4 (GNU Octave 2.0 / Matlab 4.2)", "mat" },
|
|
{ SF_FORMAT_MAT5, "MAT5 (GNU Octave 2.1 / Matlab 5.0)", "mat" },
|
|
{ SF_FORMAT_MPC2K, "MPC (Akai MPC 2k)", "mpc" },
|
|
#if HAVE_MPEG
|
|
{ SF_FORMAT_MPEG, "MPEG-1/2 Audio", "m1a" },
|
|
#endif
|
|
#if HAVE_EXTERNAL_XIPH_LIBS
|
|
{ SF_FORMAT_OGG, "OGG (OGG Container format)", "oga" },
|
|
#endif
|
|
{ SF_FORMAT_PAF, "PAF (Ensoniq PARIS)", "paf" },
|
|
{ SF_FORMAT_PVF, "PVF (Portable Voice Format)", "pvf" },
|
|
{ SF_FORMAT_RAW, "RAW (header-less)", "raw" },
|
|
{ SF_FORMAT_RF64, "RF64 (RIFF 64)", "rf64" },
|
|
{ SF_FORMAT_SD2, "SD2 (Sound Designer II)", "sd2" },
|
|
{ SF_FORMAT_SDS, "SDS (Midi Sample Dump Standard)", "sds" },
|
|
{ SF_FORMAT_IRCAM, "SF (Berkeley/IRCAM/CARL)", "sf" },
|
|
{ SF_FORMAT_VOC, "VOC (Creative Labs)", "voc" },
|
|
{ SF_FORMAT_W64, "W64 (SoundFoundry WAVE 64)", "w64" },
|
|
{ SF_FORMAT_WAV, "WAV (Microsoft)", "wav" },
|
|
{ SF_FORMAT_NIST, "WAV (NIST Sphere)", "wav" },
|
|
{ SF_FORMAT_WAVEX, "WAVEX (Microsoft)", "wav" },
|
|
{ SF_FORMAT_WVE, "WVE (Psion Series 3)", "wve" },
|
|
{ SF_FORMAT_XI, "XI (FastTracker 2)", "xi" },
|
|
|
|
} ; /* major_formats */
|
|
|
|
int
|
|
psf_get_format_major_count (void)
|
|
{ return (sizeof (major_formats) / sizeof (SF_FORMAT_INFO)) ;
|
|
} /* psf_get_format_major_count */
|
|
|
|
int
|
|
psf_get_format_major (SF_FORMAT_INFO *data)
|
|
{ int indx ;
|
|
|
|
if (data->format < 0 || data->format >= (SIGNED_SIZEOF (major_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)))
|
|
return SFE_BAD_COMMAND_PARAM ;
|
|
|
|
indx = data->format ;
|
|
memcpy (data, &(major_formats [indx]), SIGNED_SIZEOF (SF_FORMAT_INFO)) ;
|
|
|
|
return 0 ;
|
|
} /* psf_get_format_major */
|
|
|
|
/*============================================================================
|
|
** Subtype format info.
|
|
*/
|
|
|
|
static SF_FORMAT_INFO subtype_formats [] =
|
|
{
|
|
{ SF_FORMAT_PCM_S8, "Signed 8 bit PCM", NULL },
|
|
{ SF_FORMAT_PCM_16, "Signed 16 bit PCM", NULL },
|
|
{ SF_FORMAT_PCM_24, "Signed 24 bit PCM", NULL },
|
|
{ SF_FORMAT_PCM_32, "Signed 32 bit PCM", NULL },
|
|
|
|
{ SF_FORMAT_PCM_U8, "Unsigned 8 bit PCM", NULL },
|
|
|
|
{ SF_FORMAT_FLOAT, "32 bit float", NULL },
|
|
{ SF_FORMAT_DOUBLE, "64 bit float", NULL },
|
|
|
|
{ SF_FORMAT_ULAW, "U-Law", NULL },
|
|
{ SF_FORMAT_ALAW, "A-Law", NULL },
|
|
{ SF_FORMAT_IMA_ADPCM, "IMA ADPCM", NULL },
|
|
{ SF_FORMAT_MS_ADPCM, "Microsoft ADPCM", NULL },
|
|
|
|
{ SF_FORMAT_GSM610, "GSM 6.10", NULL },
|
|
|
|
{ SF_FORMAT_G721_32, "32kbs G721 ADPCM", NULL },
|
|
{ SF_FORMAT_G723_24, "24kbs G723 ADPCM", NULL },
|
|
{ SF_FORMAT_G723_40, "40kbs G723 ADPCM", NULL },
|
|
|
|
{ SF_FORMAT_DWVW_12, "12 bit DWVW", NULL },
|
|
{ SF_FORMAT_DWVW_16, "16 bit DWVW", NULL },
|
|
{ SF_FORMAT_DWVW_24, "24 bit DWVW", NULL },
|
|
{ SF_FORMAT_VOX_ADPCM, "VOX ADPCM", "vox" },
|
|
|
|
{ SF_FORMAT_NMS_ADPCM_16, "16kbs NMS ADPCM", NULL },
|
|
{ SF_FORMAT_NMS_ADPCM_24, "24kbs NMS ADPCM", NULL },
|
|
{ SF_FORMAT_NMS_ADPCM_32, "32kbs NMS ADPCM", NULL },
|
|
|
|
{ SF_FORMAT_DPCM_16, "16 bit DPCM", NULL },
|
|
{ SF_FORMAT_DPCM_8, "8 bit DPCM", NULL },
|
|
|
|
#if HAVE_EXTERNAL_XIPH_LIBS
|
|
{ SF_FORMAT_VORBIS, "Vorbis", NULL },
|
|
{ SF_FORMAT_OPUS, "Opus", NULL },
|
|
#endif
|
|
|
|
#if HAVE_MPEG
|
|
{ SF_FORMAT_MPEG_LAYER_I, "MPEG Layer I", "mp1" },
|
|
{ SF_FORMAT_MPEG_LAYER_II, "MPEG Layer II", "mp2" },
|
|
{ SF_FORMAT_MPEG_LAYER_III, "MPEG Layer III", "mp3" },
|
|
#endif
|
|
|
|
{ SF_FORMAT_ALAC_16, "16 bit ALAC", NULL },
|
|
{ SF_FORMAT_ALAC_20, "20 bit ALAC", NULL },
|
|
{ SF_FORMAT_ALAC_24, "24 bit ALAC", NULL },
|
|
{ SF_FORMAT_ALAC_32, "32 bit ALAC", NULL },
|
|
} ; /* subtype_formats */
|
|
|
|
int
|
|
psf_get_format_subtype_count (void)
|
|
{ return (sizeof (subtype_formats) / sizeof (SF_FORMAT_INFO)) ;
|
|
} /* psf_get_format_subtype_count */
|
|
|
|
int
|
|
psf_get_format_subtype (SF_FORMAT_INFO *data)
|
|
{ int indx ;
|
|
|
|
if (data->format < 0 || data->format >= (SIGNED_SIZEOF (subtype_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)))
|
|
{ data->format = 0 ;
|
|
return SFE_BAD_COMMAND_PARAM ;
|
|
} ;
|
|
|
|
indx = data->format ;
|
|
memcpy (data, &(subtype_formats [indx]), sizeof (SF_FORMAT_INFO)) ;
|
|
|
|
return 0 ;
|
|
} /* psf_get_format_subtype */
|
|
|
|
/*==============================================================================
|
|
*/
|
|
|
|
int
|
|
psf_get_format_info (SF_FORMAT_INFO *data)
|
|
{ int k, format ;
|
|
|
|
if (SF_CONTAINER (data->format))
|
|
{ format = SF_CONTAINER (data->format) ;
|
|
|
|
for (k = 0 ; k < (SIGNED_SIZEOF (major_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)) ; k++)
|
|
{ if (format == major_formats [k].format)
|
|
{ memcpy (data, &(major_formats [k]), sizeof (SF_FORMAT_INFO)) ;
|
|
return 0 ;
|
|
} ;
|
|
} ;
|
|
}
|
|
else if (SF_CODEC (data->format))
|
|
{ format = SF_CODEC (data->format) ;
|
|
|
|
for (k = 0 ; k < (SIGNED_SIZEOF (subtype_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)) ; k++)
|
|
{ if (format == subtype_formats [k].format)
|
|
{ memcpy (data, &(subtype_formats [k]), sizeof (SF_FORMAT_INFO)) ;
|
|
return 0 ;
|
|
} ;
|
|
} ;
|
|
} ;
|
|
|
|
memset (data, 0, sizeof (SF_FORMAT_INFO)) ;
|
|
|
|
return SFE_BAD_COMMAND_PARAM ;
|
|
} /* psf_get_format_info */
|
|
|
|
/*==============================================================================
|
|
*/
|
|
|
|
double
|
|
psf_calc_signal_max (SF_PRIVATE *psf, int normalize)
|
|
{ BUF_UNION ubuf ;
|
|
sf_count_t position ;
|
|
double max_val, temp, *data ;
|
|
int k, len, readcount, save_state ;
|
|
|
|
/* If the file is not seekable, there is nothing we can do. */
|
|
if (! psf->sf.seekable)
|
|
{ psf->error = SFE_NOT_SEEKABLE ;
|
|
return 0.0 ;
|
|
} ;
|
|
|
|
if (! psf->read_double)
|
|
{ psf->error = SFE_UNIMPLEMENTED ;
|
|
return 0.0 ;
|
|
} ;
|
|
|
|
save_state = sf_command ((SNDFILE*) psf, SFC_GET_NORM_DOUBLE, NULL, 0) ;
|
|
sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, normalize) ;
|
|
|
|
/* Brute force. Read the whole file and find the biggest sample. */
|
|
/* Get current position in file */
|
|
position = sf_seek ((SNDFILE*) psf, 0, SEEK_CUR) ;
|
|
/* Go to start of file. */
|
|
sf_seek ((SNDFILE*) psf, 0, SEEK_SET) ;
|
|
|
|
data = ubuf.dbuf ;
|
|
/* Make sure len is an integer multiple of the channel count. */
|
|
len = ARRAY_LEN (ubuf.dbuf) - (ARRAY_LEN (ubuf.dbuf) % psf->sf.channels) ;
|
|
|
|
for (readcount = 1, max_val = 0.0 ; readcount > 0 ; /* nothing */)
|
|
{ readcount = (int) sf_read_double ((SNDFILE*) psf, data, len) ;
|
|
for (k = 0 ; k < readcount ; k++)
|
|
{ temp = fabs (data [k]) ;
|
|
max_val = temp > max_val ? temp : max_val ;
|
|
} ;
|
|
} ;
|
|
|
|
/* Return to SNDFILE to original state. */
|
|
sf_seek ((SNDFILE*) psf, position, SEEK_SET) ;
|
|
sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, save_state) ;
|
|
|
|
return max_val ;
|
|
} /* psf_calc_signal_max */
|
|
|
|
int
|
|
psf_calc_max_all_channels (SF_PRIVATE *psf, double *peaks, int normalize)
|
|
{ BUF_UNION ubuf ;
|
|
sf_count_t position ;
|
|
double temp, *data ;
|
|
int k, len, readcount, save_state ;
|
|
int chan ;
|
|
|
|
/* If the file is not seekable, there is nothing we can do. */
|
|
if (! psf->sf.seekable)
|
|
return (psf->error = SFE_NOT_SEEKABLE) ;
|
|
|
|
if (! psf->read_double)
|
|
return (psf->error = SFE_UNIMPLEMENTED) ;
|
|
|
|
save_state = sf_command ((SNDFILE*) psf, SFC_GET_NORM_DOUBLE, NULL, 0) ;
|
|
sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, normalize) ;
|
|
|
|
memset (peaks, 0, sizeof (double) * psf->sf.channels) ;
|
|
|
|
/* Brute force. Read the whole file and find the biggest sample for each channel. */
|
|
position = sf_seek ((SNDFILE*) psf, 0, SEEK_CUR) ; /* Get current position in file */
|
|
sf_seek ((SNDFILE*) psf, 0, SEEK_SET) ; /* Go to start of file. */
|
|
|
|
len = ARRAY_LEN (ubuf.dbuf) - (ARRAY_LEN (ubuf.dbuf) % psf->sf.channels) ;
|
|
|
|
data = ubuf.dbuf ;
|
|
|
|
chan = 0 ;
|
|
readcount = len ;
|
|
while (readcount > 0)
|
|
{ readcount = (int) sf_read_double ((SNDFILE*) psf, data, len) ;
|
|
for (k = 0 ; k < readcount ; k++)
|
|
{ temp = fabs (data [k]) ;
|
|
peaks [chan] = temp > peaks [chan] ? temp : peaks [chan] ;
|
|
chan = (chan + 1) % psf->sf.channels ;
|
|
} ;
|
|
} ;
|
|
|
|
sf_seek ((SNDFILE*) psf, position, SEEK_SET) ; /* Return to original position. */
|
|
|
|
sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, save_state) ;
|
|
|
|
return 0 ;
|
|
} /* psf_calc_max_all_channels */
|
|
|
|
int
|
|
psf_get_signal_max (SF_PRIVATE *psf, double *peak)
|
|
{ int k ;
|
|
|
|
if (psf->peak_info == NULL)
|
|
return SF_FALSE ;
|
|
|
|
peak [0] = psf->peak_info->peaks [0].value ;
|
|
|
|
for (k = 1 ; k < psf->sf.channels ; k++)
|
|
peak [0] = SF_MAX (peak [0], psf->peak_info->peaks [k].value) ;
|
|
|
|
return SF_TRUE ;
|
|
} /* psf_get_signal_max */
|
|
|
|
int
|
|
psf_get_max_all_channels (SF_PRIVATE *psf, double *peaks)
|
|
{ int k ;
|
|
|
|
if (psf->peak_info == NULL)
|
|
return SF_FALSE ;
|
|
|
|
for (k = 0 ; k < psf->sf.channels ; k++)
|
|
peaks [k] = psf->peak_info->peaks [k].value ;
|
|
|
|
return SF_TRUE ;
|
|
} /* psf_get_max_all_channels */
|
|
|
|
|