libs/audiographer/private/sndfile.hh

   1 /*
   2 ** Copyright (C) 2005-2007 Erik de Castro Lopo <erikd@mega-nerd.com>
   3 **
   4 ** All rights reserved.
   5 **
   6 ** Redistribution and use in source and binary forms, with or without
   7 ** modification, are permitted provided that the following conditions are
   8 ** met:
   9 **
  10 **     * Redistributions of source code must retain the above copyright
  11 **       notice, this list of conditions and the following disclaimer.
  12 **     * Redistributions in binary form must reproduce the above copyright
  13 **       notice, this list of conditions and the following disclaimer in
  14 **       the documentation and/or other materials provided with the
  15 **       distribution.
  16 **     * Neither the author nor the names of any contributors may be used
  17 **       to endorse or promote products derived from this software without
  18 **       specific prior written permission.
  19 **
  20 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  22 ** TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23 ** PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24 ** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25 ** EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26 ** PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  27 ** OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28 ** WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29 ** OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  30 ** ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31 */
  32
  33 /*
  34 ** The above modified BSD style license (GPL and LGPL compatible) applies to
  35 ** this file. It does not apply to libsndfile itself which is released under
  36 ** the GNU LGPL or the libsndfile test suite which is released under the GNU
  37 ** GPL.
  38 ** This means that this header file can be used under this modified BSD style
  39 ** license, but the LGPL still holds for the libsndfile library itself.
  40 */
  41
  42 /*
  43 ** sndfile.hh -- A lightweight C++ wrapper for the libsndfile API.
  44 **
  45 ** All the methods are inlines and all functionality is contained in this
  46 ** file. There is no separate implementation file.
  47 **
  48 ** API documentation is in the doc/ directory of the source code tarball
  49 ** and at http://www.mega-nerd.com/libsndfile/api.html.
  50 */
  51
  52 #ifndef SNDFILE_HH
  53 #define SNDFILE_HH
  54
  55 #include <sys/types.h>
  56 #include <sys/stat.h>
  57 #include <fcntl.h>
  58
  59 #include <glib.h>
  60 #include "pbd/gstdio_compat.h"
  61
  62 #include <sndfile.h>
  63
  64 #include <string>
  65 #include <new> // for std::nothrow
  66
  67 // Prevent conflicts
  68 namespace AudioGrapher {
  69
  70 class SndfileHandle
  71 {       private :
  72                 struct SNDFILE_ref
  73                 {       SNDFILE_ref (void) ;
  74                         ~SNDFILE_ref (void) ;
  75
  76                         SNDFILE *sf ;
  77                         SF_INFO sfinfo ;
  78                         int ref ;
  79                         } ;
  80
  81                 SNDFILE_ref *p ;
  82
  83         public :
  84                         /* Default constructor */
  85                         SndfileHandle (void) : p (NULL) {} ;
  86                         SndfileHandle (const char *path, int mode = SFM_READ,
  87                                                         int format = 0, int channels = 0, int samplerate = 0) ;
  88                         SndfileHandle (std::string const & path, int mode = SFM_READ,
  89                                                         int format = 0, int channels = 0, int samplerate = 0) ;
  90                         SndfileHandle (int fd, bool close_desc, int mode = SFM_READ,
  91                                                         int format = 0, int channels = 0, int samplerate = 0) ;
  92                         ~SndfileHandle (void) ;
  93
  94                         SndfileHandle (const SndfileHandle &orig) ;
  95                         SndfileHandle & operator = (const SndfileHandle &rhs) ;
  96
  97                         void close (void) ;
  98
  99                 /* Mainly for debugging/testing. */
 100                 int refCount (void) const { return (p == NULL) ? 0 : p->ref ; }
 101
 102                 operator bool () const { return (p != NULL) ; }
 103
 104                 bool operator == (const SndfileHandle &rhs) const { return (p == rhs.p) ; }
 105
 106                 sf_count_t      frames (void) const             { return p ? p->sfinfo.frames : 0 ; }
 107                 int                     format (void) const             { return p ? p->sfinfo.format : 0 ; }
 108                 int                     channels (void) const   { return p ? p->sfinfo.channels : 0 ; }
 109                 int                     samplerate (void) const { return p ? p->sfinfo.samplerate : 0 ; }
 110
 111                 int error (void) const ;
 112                 const char * strError (void) const ;
 113
 114                 int command (int cmd, void *data, int datasize) ;
 115
 116                 sf_count_t      seek (sf_count_t frames, int whence) ;
 117
 118                 void writeSync (void) ;
 119
 120                 int setString (int str_type, const char* str) ;
 121
 122                 const char* getString (int str_type) const ;
 123
 124                 static int formatCheck (int format, int channels, int samplerate) ;
 125
 126                 sf_count_t read (short *ptr, sf_count_t items) ;
 127                 sf_count_t read (int *ptr, sf_count_t items) ;
 128                 sf_count_t read (float *ptr, sf_count_t items) ;
 129                 sf_count_t read (double *ptr, sf_count_t items) ;
 130
 131                 sf_count_t write (const short *ptr, sf_count_t items) ;
 132                 sf_count_t write (const int *ptr, sf_count_t items) ;
 133                 sf_count_t write (const float *ptr, sf_count_t items) ;
 134                 sf_count_t write (const double *ptr, sf_count_t items) ;
 135
 136                 sf_count_t readf (short *ptr, sf_count_t frames) ;
 137                 sf_count_t readf (int *ptr, sf_count_t frames) ;
 138                 sf_count_t readf (float *ptr, sf_count_t frames) ;
 139                 sf_count_t readf (double *ptr, sf_count_t frames) ;
 140
 141                 sf_count_t writef (const short *ptr, sf_count_t frames) ;
 142                 sf_count_t writef (const int *ptr, sf_count_t frames) ;
 143                 sf_count_t writef (const float *ptr, sf_count_t frames) ;
 144                 sf_count_t writef (const double *ptr, sf_count_t frames) ;
 145
 146                 sf_count_t      readRaw         (void *ptr, sf_count_t bytes) ;
 147                 sf_count_t      writeRaw        (const void *ptr, sf_count_t bytes) ;
 148
 149 } ;
 150
 151 /*==============================================================================
 152 **      Nothing but implementation below.
 153 */
 154
 155 inline
 156 SndfileHandle::SNDFILE_ref::SNDFILE_ref (void)
 157 : ref (1)
 158 {}
 159
 160 inline
 161 SndfileHandle::SNDFILE_ref::~SNDFILE_ref (void)
 162 {       if (sf != NULL) { sf_close (sf) ; } }
 163
 164
 165 void
 166 SndfileHandle::close (void)
 167 {
 168         if (p != NULL && --p->ref == 0)
 169         {
 170                 delete p ;
 171                 p = NULL;
 172         }
 173 }
 174
 175
 176 inline
 177 SndfileHandle::SndfileHandle (const char *path, int mode, int fmt, int chans, int srate)
 178 : p (NULL)
 179 {
 180         p = new (std::nothrow) SNDFILE_ref () ;
 181
 182         if (p != NULL)
 183         {       p->ref = 1 ;
 184
 185                 p->sfinfo.frames = 0 ;
 186                 p->sfinfo.channels = chans ;
 187                 p->sfinfo.format = fmt ;
 188                 p->sfinfo.samplerate = srate ;
 189                 p->sfinfo.sections = 0 ;
 190                 p->sfinfo.seekable = 0 ;
 191
 192                 bool writable = false;
 193                 if (mode & SFM_WRITE) {
 194                         writable = true;
 195                 }
 196                 if (writable) {
 197                         ::g_unlink (path);
 198                 }
 199 #ifdef PLATFORM_WINDOWS
 200                 int fd = g_open (path, writable ? O_CREAT | O_RDWR : O_RDONLY, writable ? 0644 : 0444);
 201 #else
 202                 int fd = ::open (path, writable ? O_CREAT | O_RDWR : O_RDONLY, writable ? 0644 : 0444);
 203 #endif
 204
 205                 p->sf = sf_open_fd (fd, mode, &p->sfinfo, true) ;
 206                 } ;
 207
 208         return ;
 209 } /* SndfileHandle const char * constructor */
 210
 211 inline
 212 SndfileHandle::SndfileHandle (std::string const & path, int mode, int fmt, int chans, int srate)
 213 : p (NULL)
 214 {
 215         p = new (std::nothrow) SNDFILE_ref () ;
 216
 217         if (p != NULL)
 218         {       p->ref = 1 ;
 219
 220                 p->sfinfo.frames = 0 ;
 221                 p->sfinfo.channels = chans ;
 222                 p->sfinfo.format = fmt ;
 223                 p->sfinfo.samplerate = srate ;
 224                 p->sfinfo.sections = 0 ;
 225                 p->sfinfo.seekable = 0 ;
 226
 227                 bool writable = false;
 228                 if (mode & SFM_WRITE) {
 229                         writable = true;
 230                 }
 231                 if (writable) {
 232                         ::g_unlink (path.c_str());
 233                 }
 234 #ifdef PLATFORM_WINDOWS
 235                 int fd = g_open (path.c_str(), writable ? O_CREAT | O_RDWR : O_RDONLY, writable ? 0644 : 0444);
 236 #else
 237                 int fd = ::open (path.c_str(), writable ? O_CREAT | O_RDWR : O_RDONLY, writable ? 0644 : 0444);
 238 #endif
 239
 240                 p->sf = sf_open_fd (fd, mode, &p->sfinfo, true) ;
 241                 } ;
 242
 243         return ;
 244 } /* SndfileHandle std::string constructor */
 245
 246 inline
 247 SndfileHandle::SndfileHandle (int fd, bool close_desc, int mode, int fmt, int chans, int srate)
 248 : p (NULL)
 249 {
 250         if (fd < 0)
 251                 return;
 252
 253         p = new (std::nothrow) SNDFILE_ref () ;
 254
 255         if (p != NULL)
 256         {       p->ref = 1 ;
 257
 258                 p->sfinfo.frames = 0 ;
 259                 p->sfinfo.channels = chans ;
 260                 p->sfinfo.format = fmt ;
 261                 p->sfinfo.samplerate = srate ;
 262                 p->sfinfo.sections = 0 ;
 263                 p->sfinfo.seekable = 0 ;
 264
 265                 p->sf = sf_open_fd (fd, mode, &p->sfinfo, close_desc) ;
 266                 } ;
 267
 268         return ;
 269 } /* SndfileHandle fd constructor */
 270
 271 inline
 272 SndfileHandle::~SndfileHandle (void)
 273 {       if (p != NULL && --p->ref == 0)
 274                 delete p ;
 275 } /* SndfileHandle destructor */
 276
 277
 278 inline
 279 SndfileHandle::SndfileHandle (const SndfileHandle &orig)
 280 : p (orig.p)
 281 {       if (p != NULL)
 282                 ++p->ref ;
 283 } /* SndfileHandle copy constructor */
 284
 285 inline SndfileHandle &
 286 SndfileHandle::operator = (const SndfileHandle &rhs)
 287 {
 288         if (&rhs == this)
 289                 return *this ;
 290         if (p != NULL && --p->ref == 0)
 291                 delete p ;
 292
 293         p = rhs.p ;
 294         if (p != NULL)
 295                 ++p->ref ;
 296
 297         return *this ;
 298 } /* SndfileHandle assignment operator */
 299
 300 inline int
 301 SndfileHandle::error (void) const
 302 {       return sf_error (p->sf) ; }
 303
 304 inline const char *
 305 SndfileHandle::strError (void) const
 306 {       return sf_strerror (p->sf) ; }
 307
 308 inline int
 309 SndfileHandle::command (int cmd, void *data, int datasize)
 310 {       return sf_command (p->sf, cmd, data, datasize) ; }
 311
 312 inline sf_count_t
 313 SndfileHandle::seek (sf_count_t frame_count, int whence)
 314 {       return sf_seek (p->sf, frame_count, whence) ; }
 315
 316 inline void
 317 SndfileHandle::writeSync (void)
 318 {       sf_write_sync (p->sf) ; }
 319
 320 inline int
 321 SndfileHandle::setString (int str_type, const char* str)
 322 {       return sf_set_string (p->sf, str_type, str) ; }
 323
 324 inline const char*
 325 SndfileHandle::getString (int str_type) const
 326 {       return sf_get_string (p->sf, str_type) ; }
 327
 328 inline int
 329 SndfileHandle::formatCheck(int fmt, int chans, int srate)
 330 {
 331         SF_INFO sfinfo ;
 332
 333         sfinfo.frames = 0 ;
 334         sfinfo.channels = chans ;
 335         sfinfo.format = fmt ;
 336         sfinfo.samplerate = srate ;
 337         sfinfo.sections = 0 ;
 338         sfinfo.seekable = 0 ;
 339
 340         return sf_format_check (&sfinfo) ;
 341 }
 342
 343 /*---------------------------------------------------------------------*/
 344
 345 inline sf_count_t
 346 SndfileHandle::read (short *ptr, sf_count_t items)
 347 {       return sf_read_short (p->sf, ptr, items) ; }
 348
 349 inline sf_count_t
 350 SndfileHandle::read (int *ptr, sf_count_t items)
 351 {       return sf_read_int (p->sf, ptr, items) ; }
 352
 353 inline sf_count_t
 354 SndfileHandle::read (float *ptr, sf_count_t items)
 355 {       return sf_read_float (p->sf, ptr, items) ; }
 356
 357 inline sf_count_t
 358 SndfileHandle::read (double *ptr, sf_count_t items)
 359 {       return sf_read_double (p->sf, ptr, items) ; }
 360
 361 inline sf_count_t
 362 SndfileHandle::write (const short *ptr, sf_count_t items)
 363 {       return sf_write_short (p->sf, ptr, items) ; }
 364
 365 inline sf_count_t
 366 SndfileHandle::write (const int *ptr, sf_count_t items)
 367 {       return sf_write_int (p->sf, ptr, items) ; }
 368
 369 inline sf_count_t
 370 SndfileHandle::write (const float *ptr, sf_count_t items)
 371 {       return sf_write_float (p->sf, ptr, items) ; }
 372
 373 inline sf_count_t
 374 SndfileHandle::write (const double *ptr, sf_count_t items)
 375 {       return sf_write_double (p->sf, ptr, items) ; }
 376
 377 inline sf_count_t
 378 SndfileHandle::readf (short *ptr, sf_count_t frame_count)
 379 {       return sf_readf_short (p->sf, ptr, frame_count) ; }
 380
 381 inline sf_count_t
 382 SndfileHandle::readf (int *ptr, sf_count_t frame_count)
 383 {       return sf_readf_int (p->sf, ptr, frame_count) ; }
 384
 385 inline sf_count_t
 386 SndfileHandle::readf (float *ptr, sf_count_t frame_count)
 387 {       return sf_readf_float (p->sf, ptr, frame_count) ; }
 388
 389 inline sf_count_t
 390 SndfileHandle::readf (double *ptr, sf_count_t frame_count)
 391 {       return sf_readf_double (p->sf, ptr, frame_count) ; }
 392
 393 inline sf_count_t
 394 SndfileHandle::writef (const short *ptr, sf_count_t frame_count)
 395 {       return sf_writef_short (p->sf, ptr, frame_count) ; }
 396
 397 inline sf_count_t
 398 SndfileHandle::writef (const int *ptr, sf_count_t frame_count)
 399 {       return sf_writef_int (p->sf, ptr, frame_count) ; }
 400
 401 inline sf_count_t
 402 SndfileHandle::writef (const float *ptr, sf_count_t frame_count)
 403 {       return sf_writef_float (p->sf, ptr, frame_count) ; }
 404
 405 inline sf_count_t
 406 SndfileHandle::writef (const double *ptr, sf_count_t frame_count)
 407 {       return sf_writef_double (p->sf, ptr, frame_count) ; }
 408
 409 inline sf_count_t
 410 SndfileHandle::readRaw (void *ptr, sf_count_t bytes)
 411 {       return sf_read_raw (p->sf, ptr, bytes) ; }
 412
 413 inline sf_count_t
 414 SndfileHandle::writeRaw (const void *ptr, sf_count_t bytes)
 415 {       return sf_write_raw (p->sf, ptr, bytes) ; }
 416
 417
 418 #ifdef ENABLE_SNDFILE_WINDOWS_PROTOTYPES
 419
 420 inline
 421 SndfileHandle::SndfileHandle (LPCWSTR wpath, int mode, int fmt, int chans, int srate)
 422 : p (NULL)
 423 {
 424         p = new (std::nothrow) SNDFILE_ref () ;
 425
 426         if (p != NULL)
 427         {       p->ref = 1 ;
 428
 429                 p->sfinfo.frames = 0 ;
 430                 p->sfinfo.channels = chans ;
 431                 p->sfinfo.format = fmt ;
 432                 p->sfinfo.samplerate = srate ;
 433                 p->sfinfo.sections = 0 ;
 434                 p->sfinfo.seekable = 0 ;
 435
 436                 p->sf = sf_wchar_open (wpath, mode, &p->sfinfo) ;
 437                 } ;
 438
 439         return ;
 440 } /* SndfileHandle const wchar_t * constructor */
 441
 442 #endif
 443
 444 } // namespace AudioGrapher
 445
 446 #endif  /* SNDFILE_HH */
 447