1/* 2** Copyright (C) 2007-2011 Erik de Castro Lopo <erikd@mega-nerd.com> 3** 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. 8** 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. 13** 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. 17*/ 18 19#include <octave/oct.h> 20 21#include "sndfile.h" 22 23#define FOUR_GIG (0x100000000LL) 24#define BUFFER_FRAMES 8192 25 26 27static int format_of_str (const std::string & fmt) ; 28static void string_of_format (std::string & fmt, int format) ; 29 30 31DEFUN_DLD (sfversion, args, nargout , 32"-*- texinfo -*-\n\ 33@deftypefn {Loadable Function} {@var{version} =} sfversion ()\n\ 34@cindex Reading sound files\n\ 35Return a string containing the libsndfile version.\n\ 36@seealso{sfread, sfwrite}\n\ 37@end deftypefn") 38{ char buffer [256] ; 39 octave_value_list retval ; 40 41 /* Bail out if the input parameters are bad. */ 42 if (args.length () != 0 || nargout > 1) 43 { print_usage () ; 44 return retval ; 45 } ; 46 47 sf_command (NULL, SFC_GET_LIB_VERSION, buffer, sizeof (buffer)) ; 48 49 std::string version (buffer) ; 50 51 retval.append (version) ; 52 return retval ; 53} /* sfversion */ 54 55 56DEFUN_DLD (sfread, args, nargout , 57"-*- texinfo -*-\n\ 58@deftypefn {Loadable Function} {@var{data},@var{srate},@var{format} =} sfread (@var{filename})\n\ 59@cindex Reading sound files\n\ 60Read a sound file from disk using libsndfile.\n\ 61@seealso{sfversion, sfwrite}\n\ 62@end deftypefn") 63{ SNDFILE * file ; 64 SF_INFO sfinfo ; 65 66 octave_value_list retval ; 67 68 int nargin = args.length () ; 69 70 /* Bail out if the input parameters are bad. */ 71 if ((nargin != 1) || !args (0) .is_string () || nargout < 1 || nargout > 3) 72 { print_usage () ; 73 return retval ; 74 } ; 75 76 memset (&sfinfo, 0, sizeof (sfinfo)) ; 77 78 std::string filename = args (0).string_value () ; 79 80 if ((file = sf_open (filename.c_str (), SFM_READ, &sfinfo)) == NULL) 81 { error ("sfread: couldn't open file %s : %s", filename.c_str (), sf_strerror (NULL)) ; 82 return retval ; 83 } ; 84 85 if (sfinfo.frames > FOUR_GIG) 86 printf ("This is a really huge file (%lld frames).\nYou may run out of memory trying to load it.\n", (long long) sfinfo.frames) ; 87 88 dim_vector dim = dim_vector () ; 89 dim.resize (2) ; 90 dim (0) = sfinfo.frames ; 91 dim (1) = sfinfo.channels ; 92 93 /* Should I be using Matrix instead? */ 94 NDArray out (dim, 0.0) ; 95 96 float buffer [BUFFER_FRAMES * sfinfo.channels] ; 97 int readcount ; 98 sf_count_t total = 0 ; 99 100 do 101 { readcount = sf_readf_float (file, buffer, BUFFER_FRAMES) ; 102 103 /* Make sure we don't read more frames than we allocated. */ 104 if (total + readcount > sfinfo.frames) 105 readcount = sfinfo.frames - total ; 106 107 for (int ch = 0 ; ch < sfinfo.channels ; ch++) 108 { for (int k = 0 ; k < readcount ; k++) 109 out (total + k, ch) = buffer [k * sfinfo.channels + ch] ; 110 } ; 111 112 total += readcount ; 113 } while (readcount > 0 && total < sfinfo.frames) ; 114 115 retval.append (out.squeeze ()) ; 116 117 if (nargout >= 2) 118 retval.append ((octave_uint32) sfinfo.samplerate) ; 119 120 if (nargout >= 3) 121 { std::string fmt ("") ; 122 string_of_format (fmt, sfinfo.format) ; 123 retval.append (fmt) ; 124 } ; 125 126 /* Clean up. */ 127 sf_close (file) ; 128 129 return retval ; 130} /* sfread */ 131 132DEFUN_DLD (sfwrite, args, nargout , 133"-*- texinfo -*-\n\ 134@deftypefn {Function File} sfwrite (@var{filename},@var{data},@var{srate},@var{format})\n\ 135Write a sound file to disk using libsndfile.\n\ 136@seealso{sfread, sfversion}\n\ 137@end deftypefn\n\ 138") 139{ SNDFILE * file ; 140 SF_INFO sfinfo ; 141 142 octave_value_list retval ; 143 144 int nargin = args.length () ; 145 146 /* Bail out if the input parameters are bad. */ 147 if (nargin != 4 || !args (0).is_string () || !args (1).is_real_matrix () 148 || !args (2).is_real_scalar () || !args (3).is_string () 149 || nargout != 0) 150 { print_usage () ; 151 return retval ; 152 } ; 153 154 std::string filename = args (0).string_value () ; 155 std::string format = args (3).string_value () ; 156 157 memset (&sfinfo, 0, sizeof (sfinfo)) ; 158 159 sfinfo.format = format_of_str (format) ; 160 if (sfinfo.format == 0) 161 { error ("Bad format '%s'", format.c_str ()) ; 162 return retval ; 163 } ; 164 165 sfinfo.samplerate = lrint (args (2).scalar_value ()) ; 166 if (sfinfo.samplerate < 1) 167 { error ("Bad sample rate : %d.\n", sfinfo.samplerate) ; 168 return retval ; 169 } ; 170 171 Matrix data = args (1).matrix_value () ; 172 long rows = args (1).rows () ; 173 long cols = args (1).columns () ; 174 175 if (cols > rows) 176 { error ("Audio data should have one column per channel, but supplied data " 177 "has %ld rows and %ld columns.\n", rows, cols) ; 178 return retval ; 179 } ; 180 181 sfinfo.channels = cols ; 182 183 if ((file = sf_open (filename.c_str (), SFM_WRITE, &sfinfo)) == NULL) 184 { error ("Couldn't open file %s : %s", filename.c_str (), sf_strerror (NULL)) ; 185 return retval ; 186 } ; 187 188 float buffer [BUFFER_FRAMES * sfinfo.channels] ; 189 int writecount ; 190 long total = 0 ; 191 192 do 193 { 194 writecount = BUFFER_FRAMES ; 195 196 /* Make sure we don't read more frames than we allocated. */ 197 if (total + writecount > rows) 198 writecount = rows - total ; 199 200 for (int ch = 0 ; ch < sfinfo.channels ; ch++) 201 { for (int k = 0 ; k < writecount ; k++) 202 buffer [k * sfinfo.channels + ch] = data (total + k, ch) ; 203 } ; 204 205 if (writecount > 0) 206 sf_writef_float (file, buffer, writecount) ; 207 208 total += writecount ; 209 } while (writecount > 0 && total < rows) ; 210 211 /* Clean up. */ 212 sf_close (file) ; 213 214 return retval ; 215} /* sfwrite */ 216 217 218static void 219str_split (const std::string & str, const std::string & delim, std::vector <std::string> & output) 220{ 221 unsigned int offset = 0 ; 222 size_t delim_index = 0 ; 223 224 delim_index = str.find (delim, offset) ; 225 226 while (delim_index != std::string::npos) 227 { 228 output.push_back (str.substr(offset, delim_index - offset)) ; 229 offset += delim_index - offset + delim.length () ; 230 delim_index = str.find (delim, offset) ; 231 } 232 233 output.push_back (str.substr (offset)) ; 234} /* str_split */ 235 236static int 237hash_of_str (const std::string & str) 238{ 239 int hash = 0 ; 240 241 for (unsigned k = 0 ; k < str.length () ; k++) 242 hash = (hash * 3) + tolower (str [k]) ; 243 244 return hash ; 245} /* hash_of_str */ 246 247static int 248major_format_of_hash (const std::string & str) 249{ int hash ; 250 251 hash = hash_of_str (str) ; 252 253 switch (hash) 254 { 255 case 0x5c8 : /* 'wav' */ return SF_FORMAT_WAV ; 256 case 0xf84 : /* 'aiff' */ return SF_FORMAT_AIFF ; 257 case 0x198 : /* 'au' */ return SF_FORMAT_AU ; 258 case 0x579 : /* 'paf' */ return SF_FORMAT_PAF ; 259 case 0x5e5 : /* 'svx' */ return SF_FORMAT_SVX ; 260 case 0x1118 : /* 'nist' */ return SF_FORMAT_NIST ; 261 case 0x5d6 : /* 'voc' */ return SF_FORMAT_VOC ; 262 case 0x324a : /* 'ircam' */ return SF_FORMAT_IRCAM ; 263 case 0x505 : /* 'w64' */ return SF_FORMAT_W64 ; 264 case 0x1078 : /* 'mat4' */ return SF_FORMAT_MAT4 ; 265 case 0x1079 : /* 'mat5' */ return SF_FORMAT_MAT5 ; 266 case 0x5b8 : /* 'pvf' */ return SF_FORMAT_PVF ; 267 case 0x1d1 : /* 'xi' */ return SF_FORMAT_XI ; 268 case 0x56f : /* 'htk' */ return SF_FORMAT_HTK ; 269 case 0x5aa : /* 'sds' */ return SF_FORMAT_SDS ; 270 case 0x53d : /* 'avr' */ return SF_FORMAT_AVR ; 271 case 0x11d0 : /* 'wavx' */ return SF_FORMAT_WAVEX ; 272 case 0x569 : /* 'sd2' */ return SF_FORMAT_SD2 ; 273 case 0x1014 : /* 'flac' */ return SF_FORMAT_FLAC ; 274 case 0x504 : /* 'caf' */ return SF_FORMAT_CAF ; 275 case 0x5f6 : /* 'wve' */ return SF_FORMAT_WVE ; 276 default : break ; 277 } ; 278 279 printf ("%s : hash '%s' -> 0x%x\n", __func__, str.c_str (), hash) ; 280 281 return 0 ; 282} /* major_format_of_hash */ 283 284static int 285minor_format_of_hash (const std::string & str) 286{ int hash ; 287 288 hash = hash_of_str (str) ; 289 290 switch (hash) 291 { 292 case 0x1085 : /* 'int8' */ return SF_FORMAT_PCM_S8 ; 293 case 0x358a : /* 'uint8' */ return SF_FORMAT_PCM_U8 ; 294 case 0x31b0 : /* 'int16' */ return SF_FORMAT_PCM_16 ; 295 case 0x31b1 : /* 'int24' */ return SF_FORMAT_PCM_24 ; 296 case 0x31b2 : /* 'int32' */ return SF_FORMAT_PCM_32 ; 297 case 0x3128 : /* 'float' */ return SF_FORMAT_FLOAT ; 298 case 0x937d : /* 'double' */ return SF_FORMAT_DOUBLE ; 299 case 0x11bd : /* 'ulaw' */ return SF_FORMAT_ULAW ; 300 case 0xfa1 : /* 'alaw' */ return SF_FORMAT_ALAW ; 301 case 0xfc361 : /* 'ima_adpcm' */ return SF_FORMAT_IMA_ADPCM ; 302 case 0x5739a : /* 'ms_adpcm' */ return SF_FORMAT_MS_ADPCM ; 303 case 0x9450 : /* 'gsm610' */ return SF_FORMAT_GSM610 ; 304 case 0x172a3 : /* 'g721_32' */ return SF_FORMAT_G721_32 ; 305 case 0x172d8 : /* 'g723_24' */ return SF_FORMAT_G723_24 ; 306 case 0x172da : /* 'g723_40' */ return SF_FORMAT_G723_40 ; 307 default : break ; 308 } ; 309 310 printf ("%s : hash '%s' -> 0x%x\n", __func__, str.c_str (), hash) ; 311 312 return 0 ; 313} /* minor_format_of_hash */ 314 315 316static const char * 317string_of_major_format (int format) 318{ 319 switch (format & SF_FORMAT_TYPEMASK) 320 { 321 case SF_FORMAT_WAV : return "wav" ; 322 case SF_FORMAT_AIFF : return "aiff" ; 323 case SF_FORMAT_AU : return "au" ; 324 case SF_FORMAT_PAF : return "paf" ; 325 case SF_FORMAT_SVX : return "svx" ; 326 case SF_FORMAT_NIST : return "nist" ; 327 case SF_FORMAT_VOC : return "voc" ; 328 case SF_FORMAT_IRCAM : return "ircam" ; 329 case SF_FORMAT_W64 : return "w64" ; 330 case SF_FORMAT_MAT4 : return "mat4" ; 331 case SF_FORMAT_MAT5 : return "mat5" ; 332 case SF_FORMAT_PVF : return "pvf" ; 333 case SF_FORMAT_XI : return "xi" ; 334 case SF_FORMAT_HTK : return "htk" ; 335 case SF_FORMAT_SDS : return "sds" ; 336 case SF_FORMAT_AVR : return "avr" ; 337 case SF_FORMAT_WAVEX : return "wavx" ; 338 case SF_FORMAT_SD2 : return "sd2" ; 339 case SF_FORMAT_FLAC : return "flac" ; 340 case SF_FORMAT_CAF : return "caf" ; 341 case SF_FORMAT_WVE : return "wfe" ; 342 default : break ; 343 } ; 344 345 return "unknown" ; 346} /* string_of_major_format */ 347 348static const char * 349string_of_minor_format (int format) 350{ 351 switch (format & SF_FORMAT_SUBMASK) 352 { 353 case SF_FORMAT_PCM_S8 : return "int8" ; 354 case SF_FORMAT_PCM_U8 : return "uint8" ; 355 case SF_FORMAT_PCM_16 : return "int16" ; 356 case SF_FORMAT_PCM_24 : return "int24" ; 357 case SF_FORMAT_PCM_32 : return "int32" ; 358 case SF_FORMAT_FLOAT : return "float" ; 359 case SF_FORMAT_DOUBLE : return "double" ; 360 case SF_FORMAT_ULAW : return "ulaw" ; 361 case SF_FORMAT_ALAW : return "alaw" ; 362 case SF_FORMAT_IMA_ADPCM : return "ima_adpcm" ; 363 case SF_FORMAT_MS_ADPCM : return "ms_adpcm" ; 364 case SF_FORMAT_GSM610 : return "gsm610" ; 365 case SF_FORMAT_G721_32 : return "g721_32" ; 366 case SF_FORMAT_G723_24 : return "g723_24" ; 367 case SF_FORMAT_G723_40 : return "g723_40" ; 368 default : break ; 369 } ; 370 371 return "unknown" ; 372} /* string_of_minor_format */ 373 374static int 375format_of_str (const std::string & fmt) 376{ 377 std::vector <std::string> split ; 378 379 str_split (fmt, "-", split) ; 380 381 if (split.size () != 2) 382 return 0 ; 383 384 int major_fmt = major_format_of_hash (split.at (0)) ; 385 if (major_fmt == 0) 386 return 0 ; 387 388 int minor_fmt = minor_format_of_hash (split.at (1)) ; 389 if (minor_fmt == 0) 390 return 0 ; 391 392 return major_fmt | minor_fmt ; 393} /* format_of_str */ 394 395static void 396string_of_format (std::string & fmt, int format) 397{ 398 char buffer [64] ; 399 400 snprintf (buffer, sizeof (buffer), "%s-%s", string_of_major_format (format), string_of_minor_format (format)) ; 401 402 fmt = buffer ; 403 404 return ; 405} /* string_of_format */ 406