---

/root/src/subsynth/syn/Util/AudioFormat.h

Go to the documentation of this file.

/****************** <SYN heading BEGIN do not edit this line> *****************
 *
 * subsynth - modular audio synthesizer
 * subsynth is (C) Copyright 2001-2002 by Kevin Meinert
 *
 * Original Author: Kevin Meinert
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: AudioFormat.h,v $
 * Date modified: $Date: 2002/04/14 19:56:42 $
 * Version:       $Revision: 1.37 $
 * -----------------------------------------------------------------
 *
 ****************** <SYN heading END do not edit this line> ******************/

#ifndef SUBSYNTH_AUDIO_FORMAT_UTILS____
#define SUBSYNTH_AUDIO_FORMAT_UTILS____

#include <assert.h>
#include <vector>
#include <iostream>
#include <memory.h> // memcpy...
#ifdef max
#undef max
#endif

#ifdef min
#undef min
#endif

namespace syn
{
   template <typename type>
   class audio_data_traits
   {
   public:
      static type  min();
      static type  max();
      static type  bytes();
      static int range();
      static float rangef();

      static type  one_fourth_range();
   };   

   template <>
   class audio_data_traits<float>
   {
   public:
      static float min() { return -1.0f; }
      static float max() { return 1.0f; }
      static float bytes() { return 4; }
      static float rangef() { return 2.0f; }
      static int range() { return (int)rangef(); }
      
      static float one_fourth_range() 
      { return range() / 4.0f; }
   };

   template <>
   class audio_data_traits<signed char>
   {
   public:
      static signed char min() { return -128; }
      static signed char max() { return 127; }
      static signed char bytes() { return 1; }
      static int range() { return 256; }
      static float rangef() 
      { return (float)range(); }

      static signed char one_fourth_range() 
      { return range() / 4; }
   };

   template <>
   class audio_data_traits<unsigned char>
   {
   public:
      static unsigned char min() { return 0; }
      static unsigned char max() { return 255; }
      static unsigned char bytes() { return 1; }
      static int range() { return 256; }
      static float rangef()
      { return (float)range(); }

      static unsigned char one_fourth_range()
      { return range() / 4; }
   };

   template <>
   class audio_data_traits<signed short>
   {
   public:
      static signed short min() { return -32768; }
      static signed short max() { return 32767; }
      static signed short bytes() { return 2; }
      static int range() { return 65536; }
      static float rangef() 
      { return (float)range(); }
      
      static signed short one_fourth_range() 
      { return range() / 4; }
   };

   template <>
   class audio_data_traits<unsigned short>
   {
   public:
      static unsigned short min() { return 0; }
      static unsigned short max() { return 65535; }
      static unsigned short bytes() { return 2; }
      static int range() { return 65536; }
      static float rangef() 
      { return (float)range(); }
      
      static unsigned short one_fourth_range() 
      { return range() / 4; }
   };

   template <typename in, typename out>
   inline void audio_convert( const in& i, out& o )
   {
      const in in_range = audio_data_traits<in>::one_fourth_range();
      const in in_min = audio_data_traits<in>::min();
      //const in in_max = audio_data_traits<in>::max();
      const out out_range = audio_data_traits<out>::one_fourth_range();
      const out out_min = audio_data_traits<out>::min();
      //const out out_max = audio_data_traits<out>::max();

      // degenerate case: types are the same, no conversion needed
      /*
      if (in_range == out_range && in_min == out_min && in_max == out_max)
      {
         // we should never get here
         assert( false );
         return;
      }
      */
      
      // do conversion:
      // offset by <in>::min, then scale, then offset back by <out>::min
         
      // when <in> is larger capacity type...
      if ( (audio_data_traits<in>::range() >= audio_data_traits<out>::range() ||
         // special case, float is bigger capacity data type than all others...
           audio_data_traits<in>::range() == audio_data_traits<float>::range()) &&
           audio_data_traits<out>::range() != audio_data_traits<float>::range() ) 
      {
         const in scale = ((in)out_range) / in_range;
         const in inv_scale = in_range / ((in)out_range);
         if (scale != 0.0) // float to int (float mult, 2 adds)
            o = (out) (((i - in_min) * scale) + out_min);
         else              // 16 to 8 bit (shift right, 2 adds)
            o = (out) (((i - in_min) / inv_scale) + out_min);
      }
      else // <out> is larger capacity type
      {
         const out scale = out_range / ((out)in_range);
         assert( scale != 0.0 && "scale should never be 0 in this case" ); 
         
         // 8 to 16 bit conversion (shift left, 2 adds)
         // integer to float (float mult, 2 float adds)
         o = (out) (((i - in_min) * scale) + out_min);
      }

      // degenerate case: float(1.0) to int(0) is incorrect
      if (audio_data_traits<in>::range() == audio_data_traits<float>::range() && 
         audio_data_traits<out>::range() != audio_data_traits<float>::range() && 
          i >= 0.9999f)
          o -= (out)1;
   }

   template <> inline void audio_convert( const signed char& i, signed char& o ) { o = i; }
   template <> inline void audio_convert( const unsigned char& i, unsigned char& o ) { o = i; }
   template <> inline void audio_convert( const signed short& i, signed short& o ) { o = i; }
   template <> inline void audio_convert( const unsigned short& i, unsigned short& o ) { o = i; }
   template <> inline void audio_convert( const float& i, float& o ) { o = i; }
   

   
   
   class AudioFormat
   {
   public:
      enum Packing
      {
         INTERLACED
      };

      enum SampleType
      {
         UNSIGNED8, SIGNED8,
         UNSIGNED16, SIGNED16,
         FLOAT32 // FLOAT64 unsupported for now..
      };
      
      AudioFormat( SampleType dt = FLOAT32, int chan = 1, int sampRate = 44100 ) : samplingRateHz( sampRate ),
                      channels( chan ),
                      datatype( dt )
      {
      }
      
      void copy( const AudioFormat& af )
      {
         samplingRateHz = af.samplingRateHz;
         channels = af.channels; 
         datatype = af.datatype;
      }

      AudioFormat( const AudioFormat& af )
      {
         this->copy( af );
      }
            
      const AudioFormat& operator=( const AudioFormat& af )
      {
         this->copy( af );
         return *this;
      }
      
      bool operator==( const AudioFormat& af ) const
      {
         if (af.channels == this->channels &&
             af.datatype == this->datatype &&
             af.samplingRateHz == this->samplingRateHz)
         {
            return true;
         } 
         return false;
      }

      bool operator!=( const AudioFormat& af ) const 
      {
         return !this->operator==( af );
      }
      
      inline int sampsize() const
      {
         switch (datatype)
         {
         case UNSIGNED8: case SIGNED8:
            return 1;
         case UNSIGNED16: case SIGNED16:
            return 2;
         case FLOAT32:
            return 4;
         default:
            std::cout << "error: sampsize==" << datatype << std::endl;
            assert( false && "unknown sampsize" );
            return 0;
         }
      }
      
      int         samplingRateHz;// 44100, 22050
      
      int         channels;      // 1 == mono, 2 == stereo, 4 == quad, 8 == oct

      SampleType  datatype;
   };


   inline void* new_audio_data( const AudioFormat& fmt, int samples )
   {
      char* bok = new char[samples * fmt.channels * fmt.sampsize()];
      return (void*)bok;
   }

   inline void delete_audio_data( void* d )
   {
      delete[] (char*)d;
   }

   template <typename in, typename out>
   inline void size_calculator( const unsigned int& srcbytes, unsigned int& destbytes )
   {
      const float in_bytes = (float)audio_data_traits<in>::bytes();
      const float out_bytes = (float)audio_data_traits<out>::bytes();
      const float scale = in_bytes / out_bytes;
      destbytes = (unsigned int) (((float)srcbytes) * scale);
   }

   inline void size_calculator( const AudioFormat& srcfmt, AudioFormat destfmt, const unsigned int& srcbytes, unsigned int& destbytes )
   {
      const float in_bytes = (float)srcfmt.sampsize();
      const float out_bytes = (float)destfmt.sampsize();
      const float scale = in_bytes / out_bytes;
      destbytes = (unsigned int) (((float)srcbytes) * scale);
   }
   
   inline void bytes_calculator( AudioFormat fmt, const unsigned int& samples, unsigned int& destbytes )
   {
      destbytes = samples * fmt.sampsize();
   }

   inline bool audio_channels_convert( const AudioFormat& srcfmt, 
                                       const AudioFormat& destfmt, 
                                       const void* srcdata, 
                                       const int samples, 
                                       void* destdata, int& destsamples )
   {
      destsamples = samples;
      assert( destfmt.sampsize() == srcfmt.sampsize() );
      int item_size = srcfmt.sampsize();
            
      // nothing to do
      if (srcfmt.channels == destfmt.channels)
         return false;
      
      // split
      const char* srcptr = (const char*)srcdata;
      char* destptr = (char*)destdata;
      if (srcfmt.channels == 1 && destfmt.channels == 2)
      {
         destsamples = samples * 2;
         for (int x = 0; x < samples * item_size; x += item_size)
         {
            memcpy( &destptr[x * destfmt.channels], &srcptr[x * srcfmt.channels], item_size );
            memcpy( &destptr[x * destfmt.channels + item_size], &srcptr[x * srcfmt.channels], item_size );
         }
      }      
      // mixdown
      else if (srcfmt.channels == 2 && destfmt.channels == 1)
      {
         destsamples = samples / 2;
         for (int x = 0; x < samples * item_size; x += item_size)
         {
            // fast mixdown (throw out one channel), rewrite this to also support the correct one...
            memcpy( &destptr[x * destfmt.channels], &srcptr[x * srcfmt.channels], item_size );
         }
      }
      return true;
   }
   
   inline bool audio_samprate_convert( const AudioFormat& srcfmt, 
                            const AudioFormat& destfmt, 
                            const void* srcdata, 
                            const int samples, 
                            void* destdata ) 
   {return false;}
   
   template< typename t, int stride >
   inline const t* audio_iterate( const t* data, int x )
   {
      return &data[x * stride];
   }   
   
   inline const char* audio_iterate( const char* data, const AudioFormat& fmt, int x )
   {
      return &data[x * fmt.channels * fmt.sampsize()];
   }
   
   inline bool audio_format_convert( const AudioFormat& srcfmt, 
                            const AudioFormat& destfmt, 
                            const void* srcdata, 
                            const int samples, 
                            void* destdata )
   {
      const AudioFormat::SampleType& srctype = srcfmt.datatype;
      const AudioFormat::SampleType& desttype = destfmt.datatype;
      
      assert( srcfmt.samplingRateHz == destfmt.samplingRateHz 
         && "no rate conversion right now sorry." );
      assert( srcfmt.channels == destfmt.channels
         && "channels gotta be the same, sorry..." );
      
      int x;
      switch (srctype)
      {
      case AudioFormat::UNSIGNED8:
         switch (desttype)
         {
         case AudioFormat::UNSIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned char*)srcdata)[x], ((unsigned char*)destdata)[x] );
            break;
         case AudioFormat::SIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned char*)srcdata)[x], ((signed char*)destdata)[x] );
            break;
         case AudioFormat::UNSIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned char*)srcdata)[x], ((unsigned short*)destdata)[x] );
            break;
         case AudioFormat::SIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned char*)srcdata)[x], ((signed short*)destdata)[x] );
            break;
         case AudioFormat::FLOAT32:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned char*)srcdata)[x], ((float*)destdata)[x] );
            break;
         }
         break;
      case AudioFormat::SIGNED8:
         switch (desttype)
         {
         case AudioFormat::UNSIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed char*)srcdata)[x], ((unsigned char*)destdata)[x] );
            break;
         case AudioFormat::SIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed char*)srcdata)[x], ((signed char*)destdata)[x] );
            break;
         case AudioFormat::UNSIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed char*)srcdata)[x], ((unsigned short*)destdata)[x] );
            break;
         case AudioFormat::SIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed char*)srcdata)[x], ((signed short*)destdata)[x] );
            break;
         case AudioFormat::FLOAT32:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed char*)srcdata)[x], ((float*)destdata)[x] );
            break;
         }
         break;
      case AudioFormat::UNSIGNED16:
         switch (desttype)
         {
         case AudioFormat::UNSIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned short*)srcdata)[x], ((unsigned char*)destdata)[x] );
            break;
         case AudioFormat::SIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned short*)srcdata)[x], ((signed char*)destdata)[x] );
            break;
         case AudioFormat::UNSIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned short*)srcdata)[x], ((unsigned short*)destdata)[x] );
            break;
         case AudioFormat::SIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned short*)srcdata)[x], ((signed short*)destdata)[x] );
            break;
         case AudioFormat::FLOAT32:
            for (x = 0; x < samples; ++x)
               audio_convert( ((unsigned short*)srcdata)[x], ((float*)destdata)[x] );
            break;
         }
         break;
      case AudioFormat::SIGNED16:
         switch (desttype)
         {
         case AudioFormat::UNSIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed short*)srcdata)[x], ((unsigned char*)destdata)[x] );
            break;
         case AudioFormat::SIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed short*)srcdata)[x], ((signed char*)destdata)[x] );
            break;
         case AudioFormat::UNSIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed short*)srcdata)[x], ((unsigned short*)destdata)[x] );
            break;
         case AudioFormat::SIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed short*)srcdata)[x], ((signed short*)destdata)[x] );
            break;
         case AudioFormat::FLOAT32:
            for (x = 0; x < samples; ++x)
               audio_convert( ((signed short*)srcdata)[x], ((float*)destdata)[x] );
            break;
         }
         break;
      case AudioFormat::FLOAT32:
         switch (desttype)
         {
         case AudioFormat::UNSIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((float*)srcdata)[x], ((unsigned char*)destdata)[x] );
            break;
         case AudioFormat::SIGNED8:
            for (x = 0; x < samples; ++x)
               audio_convert( ((float*)srcdata)[x], ((signed char*)destdata)[x] );
            break;
         case AudioFormat::UNSIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((float*)srcdata)[x], ((unsigned short*)destdata)[x] );
            break;
         case AudioFormat::SIGNED16:
            for (x = 0; x < samples; ++x)
               audio_convert( ((float*)srcdata)[x], ((signed short*)destdata)[x] );
            break;
         case AudioFormat::FLOAT32:
            for (x = 0; x < samples; ++x)
               audio_convert( ((float*)srcdata)[x], ((float*)destdata)[x] );
            break;
         }
         break;
      }

      return true;
   }
   
   inline bool audio_convert( const AudioFormat& srcfmt, 
                            const AudioFormat& destfmt, 
                            const void* srcdata, 
                            const int samples, 
                            void* destdata, int& destsamples )
   {
      // do channel conversion if needed...
      AudioFormat temp_fmt;
      const char* channel_convert_temp_buffer = NULL;
      std::vector<char> mChannelConvertTempBuffer; // move this !  very bad to allocate this here...
      if (srcfmt.channels != destfmt.channels)
      {
         temp_fmt = srcfmt;
         temp_fmt.channels = destfmt.channels;
         unsigned int bytes;
         bytes_calculator( temp_fmt, samples * temp_fmt.channels, bytes );
         if (mChannelConvertTempBuffer.size() < bytes) // only grow it... (prevent thrashing)
            mChannelConvertTempBuffer.resize( bytes );

         audio_channels_convert( srcfmt, temp_fmt, srcdata, samples, &mChannelConvertTempBuffer[0], destsamples );
         channel_convert_temp_buffer = &mChannelConvertTempBuffer[0];
      }
      else
      {
         temp_fmt = srcfmt;
         channel_convert_temp_buffer = (const char*)srcdata;
         destsamples = samples;
      }   
      
      // do format conversion if needed
      assert( temp_fmt.channels == destfmt.channels );
      return audio_format_convert( temp_fmt, destfmt, channel_convert_temp_buffer, destsamples, destdata );
   }

   template <class type>
   type audio_clamp( const type& t )
   {
      if (t > audio_data_traits<type>::max())
         return audio_data_traits<type>::max();
      else if (t < audio_data_traits<type>::min())
         return audio_data_traits<type>::min();
      
      return t;
   }
      
} // end namespace


#endif

---