2 ** Copyright (C) 2001-2004 Erik de Castro Lopo <erikd@mega-nerd.com>
4 ** This program is free software; you can redistribute it and/or modify
5 ** it under the terms of the GNU Lesser General Public License as published by
6 ** the Free Software Foundation; either version 2.1 of the License, or
7 ** (at your option) any later version.
9 ** This program is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 ** GNU Lesser General Public License for more details.
14 ** You should have received a copy of the GNU Lesser General Public License
15 ** along with this program; if not, write to the Free Software
16 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
28 static SF_FORMAT_INFO const simple_formats [] =
30 { SF_FORMAT_AIFF | SF_FORMAT_PCM_16,
31 "AIFF (Apple/SGI 16 bit PCM)", "aiff"
34 { SF_FORMAT_AIFF | SF_FORMAT_FLOAT,
35 "AIFF (Apple/SGI 32 bit float)", "aifc"
38 { SF_FORMAT_AIFF | SF_FORMAT_PCM_S8,
39 "AIFF (Apple/SGI 8 bit PCM)", "aiff"
42 { SF_FORMAT_AU | SF_FORMAT_PCM_16,
43 "AU (Sun/Next 16 bit PCM)", "au"
46 { SF_FORMAT_AU | SF_FORMAT_ULAW,
47 "AU (Sun/Next 8-bit u-law)", "au"
50 { SF_FORMAT_CAF | SF_FORMAT_PCM_16,
51 "CAF (Apple 16 bit PCM)", "caf"
54 #ifdef HAVE_FLAC_ALL_H
55 { SF_FORMAT_FLAC | SF_FORMAT_PCM_16,
60 { SF_FORMAT_RAW | SF_FORMAT_VOX_ADPCM,
61 "OKI Dialogic VOX ADPCM", "vox"
64 { SF_FORMAT_WAV | SF_FORMAT_PCM_16,
65 "WAV (Microsoft 16 bit PCM)", "wav"
68 { SF_FORMAT_WAV | SF_FORMAT_FLOAT,
69 "WAV (Microsoft 32 bit float)", "wav"
72 { SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM,
73 "WAV (Microsoft 4 bit IMA ADPCM)", "wav"
76 { SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM,
77 "WAV (Microsoft 4 bit MS ADPCM)", "wav"
80 { SF_FORMAT_WAV | SF_FORMAT_PCM_U8,
81 "WAV (Microsoft 8 bit PCM)", "wav"
84 } ; /* simple_formats */
87 psf_get_format_simple_count (void)
88 { return (sizeof (simple_formats) / sizeof (SF_FORMAT_INFO)) ;
89 } /* psf_get_format_simple_count */
92 psf_get_format_simple (SF_FORMAT_INFO *data)
95 if (data->format < 0 || data->format >= (SIGNED_SIZEOF (simple_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)))
96 return SFE_BAD_CONTROL_CMD ;
99 memcpy (data, &(simple_formats [indx]), SIGNED_SIZEOF (SF_FORMAT_INFO)) ;
102 } /* psf_get_format_simple */
104 /*============================================================================
105 ** Major format info.
108 static SF_FORMAT_INFO const major_formats [] =
110 { SF_FORMAT_AIFF, "AIFF (Apple/SGI)", "aiff" },
111 { SF_FORMAT_AU, "AU (Sun/NeXT)", "au" },
112 { SF_FORMAT_AVR, "AVR (Audio Visual Research)", "avr" },
113 { SF_FORMAT_CAF, "CAF (Apple Core Audio File)", "caf" },
114 #ifdef HAVE_FLAC_ALL_H
115 { SF_FORMAT_FLAC, "FLAC (FLAC Lossless Audio Codec)", "flac" },
117 { SF_FORMAT_HTK, "HTK (HMM Tool Kit)", "htk" },
118 { SF_FORMAT_SVX, "IFF (Amiga IFF/SVX8/SV16)", "iff" },
119 { SF_FORMAT_MAT4, "MAT4 (GNU Octave 2.0 / Matlab 4.2)", "mat" },
120 { SF_FORMAT_MAT5, "MAT5 (GNU Octave 2.1 / Matlab 5.0)", "mat" },
121 { SF_FORMAT_PAF, "PAF (Ensoniq PARIS)", "paf" },
122 { SF_FORMAT_PVF, "PVF (Portable Voice Format)", "pvf" },
123 { SF_FORMAT_RAW, "RAW (header-less)", "raw" },
124 { SF_FORMAT_SD2, "SD2 (Sound Designer II)", "sd2" },
125 { SF_FORMAT_SDS, "SDS (Midi Sample Dump Standard)", "sds" },
126 { SF_FORMAT_IRCAM, "SF (Berkeley/IRCAM/CARL)", "sf" },
127 { SF_FORMAT_VOC, "VOC (Creative Labs)", "voc" },
128 { SF_FORMAT_W64, "W64 (SoundFoundry WAVE 64)", "w64" },
129 { SF_FORMAT_WAV, "WAV (Microsoft)", "wav" },
130 { SF_FORMAT_NIST, "WAV (NIST Sphere)", "wav" },
131 { SF_FORMAT_WAVEX, "WAVEX (Microsoft)", "wav" },
132 { SF_FORMAT_XI, "XI (FastTracker 2)", "xi" },
134 } ; /* major_formats */
137 psf_get_format_major_count (void)
138 { return (sizeof (major_formats) / sizeof (SF_FORMAT_INFO)) ;
139 } /* psf_get_format_major_count */
142 psf_get_format_major (SF_FORMAT_INFO *data)
145 if (data->format < 0 || data->format >= (SIGNED_SIZEOF (major_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)))
146 return SFE_BAD_CONTROL_CMD ;
148 indx = data->format ;
149 memcpy (data, &(major_formats [indx]), SIGNED_SIZEOF (SF_FORMAT_INFO)) ;
152 } /* psf_get_format_major */
154 /*============================================================================
155 ** Subtype format info.
158 static SF_FORMAT_INFO subtype_formats [] =
160 { SF_FORMAT_PCM_S8, "Signed 8 bit PCM", NULL },
161 { SF_FORMAT_PCM_16, "Signed 16 bit PCM", NULL },
162 { SF_FORMAT_PCM_24, "Signed 24 bit PCM", NULL },
163 { SF_FORMAT_PCM_32, "Signed 32 bit PCM", NULL },
165 { SF_FORMAT_PCM_U8, "Unsigned 8 bit PCM", NULL },
167 { SF_FORMAT_FLOAT, "32 bit float", NULL },
168 { SF_FORMAT_DOUBLE, "64 bit float", NULL },
170 { SF_FORMAT_ULAW, "U-Law", NULL },
171 { SF_FORMAT_ALAW, "A-Law", NULL },
172 { SF_FORMAT_IMA_ADPCM, "IMA ADPCM", NULL },
173 { SF_FORMAT_MS_ADPCM, "Microsoft ADPCM", NULL },
175 { SF_FORMAT_GSM610, "GSM 6.10", NULL },
177 { SF_FORMAT_G721_32, "32kbs G721 ADPCM", NULL },
178 { SF_FORMAT_G723_24, "24kbs G723 ADPCM", NULL },
180 { SF_FORMAT_DWVW_12, "12 bit DWVW", NULL },
181 { SF_FORMAT_DWVW_16, "16 bit DWVW", NULL },
182 { SF_FORMAT_DWVW_24, "24 bit DWVW", NULL },
183 { SF_FORMAT_VOX_ADPCM, "VOX ADPCM", "vox" },
185 { SF_FORMAT_DPCM_16, "16 bit DPCM", NULL },
186 { SF_FORMAT_DPCM_8, "8 bit DPCM", NULL }
187 } ; /* subtype_formats */
190 psf_get_format_subtype_count (void)
191 { return (sizeof (subtype_formats) / sizeof (SF_FORMAT_INFO)) ;
192 } /* psf_get_format_subtype_count */
195 psf_get_format_subtype (SF_FORMAT_INFO *data)
198 if (data->format < 0 || data->format >= (SIGNED_SIZEOF (subtype_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)))
199 return SFE_BAD_CONTROL_CMD ;
201 indx = data->format ;
202 memcpy (data, &(subtype_formats [indx]), sizeof (SF_FORMAT_INFO)) ;
205 } /* psf_get_format_subtype */
207 /*==============================================================================
211 psf_get_format_info (SF_FORMAT_INFO *data)
214 if (data->format & SF_FORMAT_TYPEMASK)
215 { format = data->format & SF_FORMAT_TYPEMASK ;
217 for (k = 0 ; k < (SIGNED_SIZEOF (major_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)) ; k++)
218 { if (format == major_formats [k].format)
219 { memcpy (data, &(major_formats [k]), sizeof (SF_FORMAT_INFO)) ;
224 else if (data->format & SF_FORMAT_SUBMASK)
225 { format = data->format & SF_FORMAT_SUBMASK ;
227 for (k = 0 ; k < (SIGNED_SIZEOF (subtype_formats) / SIGNED_SIZEOF (SF_FORMAT_INFO)) ; k++)
228 { if (format == subtype_formats [k].format)
229 { memcpy (data, &(subtype_formats [k]), sizeof (SF_FORMAT_INFO)) ;
235 memset (data, 0, sizeof (SF_FORMAT_INFO)) ;
237 return SFE_BAD_CONTROL_CMD ;
238 } /* psf_get_format_info */
240 /*==============================================================================
244 psf_calc_signal_max (SF_PRIVATE *psf, int normalize)
245 { sf_count_t position ;
246 double max_val, temp, *data ;
247 int k, len, readcount, save_state ;
249 /* If the file is not seekable, there is nothing we can do. */
250 if (! psf->sf.seekable)
251 { psf->error = SFE_NOT_SEEKABLE ;
255 if (! psf->read_double)
256 { psf->error = SFE_UNIMPLEMENTED ;
260 save_state = sf_command ((SNDFILE*) psf, SFC_GET_NORM_DOUBLE, NULL, 0) ;
261 sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, normalize) ;
263 /* Brute force. Read the whole file and find the biggest sample. */
264 /* Get current position in file */
265 position = sf_seek ((SNDFILE*) psf, 0, SEEK_CUR) ;
266 /* Go to start of file. */
267 sf_seek ((SNDFILE*) psf, 0, SEEK_SET) ;
270 len = ARRAY_LEN (psf->u.dbuf) ;
272 for (readcount = 1, max_val = 0.0 ; readcount > 0 ; /* nothing */)
273 { readcount = sf_read_double ((SNDFILE*) psf, data, len) ;
274 for (k = 0 ; k < readcount ; k++)
275 { temp = fabs (data [k]) ;
276 max_val = temp > max_val ? temp : max_val ;
280 /* Return to SNDFILE to original state. */
281 sf_seek ((SNDFILE*) psf, position, SEEK_SET) ;
282 sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, save_state) ;
285 } /* psf_calc_signal_max */
288 psf_calc_max_all_channels (SF_PRIVATE *psf, double *peaks, int normalize)
289 { sf_count_t position ;
291 int k, len, readcount, save_state ;
294 /* If the file is not seekable, there is nothing we can do. */
295 if (! psf->sf.seekable)
296 return (psf->error = SFE_NOT_SEEKABLE) ;
298 if (! psf->read_double)
299 return (psf->error = SFE_UNIMPLEMENTED) ;
301 save_state = sf_command ((SNDFILE*) psf, SFC_GET_NORM_DOUBLE, NULL, 0) ;
302 sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, normalize) ;
304 memset (peaks, 0, sizeof (double) * psf->sf.channels) ;
306 /* Brute force. Read the whole file and find the biggest sample for each channel. */
307 position = sf_seek ((SNDFILE*) psf, 0, SEEK_CUR) ; /* Get current position in file */
308 sf_seek ((SNDFILE*) psf, 0, SEEK_SET) ; /* Go to start of file. */
310 len = ARRAY_LEN (psf->u.dbuf) ;
316 while (readcount > 0)
317 { readcount = sf_read_double ((SNDFILE*) psf, data, len) ;
318 for (k = 0 ; k < readcount ; k++)
319 { temp = fabs (data [k]) ;
320 peaks [chan] = temp > peaks [chan] ? temp : peaks [chan] ;
321 chan = (chan + 1) % psf->sf.channels ;
325 sf_seek ((SNDFILE*) psf, position, SEEK_SET) ; /* Return to original position. */
327 sf_command ((SNDFILE*) psf, SFC_SET_NORM_DOUBLE, NULL, save_state) ;
330 } /* psf_calc_max_all_channels */
333 psf_get_signal_max (SF_PRIVATE *psf, double *peak)
336 if (psf->peak_info == NULL)
339 peak [0] = psf->peak_info->peaks [0].value ;
341 for (k = 1 ; k < psf->sf.channels ; k++)
342 peak [0] = SF_MAX (peak [0], psf->peak_info->peaks [k].value) ;
345 } /* psf_get_signal_max */
348 psf_get_max_all_channels (SF_PRIVATE *psf, double *peaks)
351 if (psf->peak_info == NULL)
354 for (k = 0 ; k < psf->sf.channels ; k++)
355 peaks [k] = psf->peak_info->peaks [k].value ;
358 } /* psf_get_max_all_channels */
362 ** Do not edit or modify anything in this comment block.
363 ** The arch-tag line is a file identity tag for the GNU Arch
364 ** revision control system.
366 ** arch-tag: 0aae0d9d-ab2b-4d70-ade3-47a534666f8e