aflibdata.cc

一个共享源码的音频库2

         max_value = 32768;
      break;

      case AFLIB_DATA_16U:
         min_value = 0;
         max_value = 65536;
      break;

      case AFLIB_DATA_32S:
         min_value = -2147483646;
         max_value = 2147483647;
      break;

      default:
         min_value = 0;
         max_value = 0;
      break;
   }
}


void
aflibData::setHostEndian()
{
   // This private function is called from constructors and gets the endian of
   // the platform this this object is currently running on.

   unsigned short seven = 7;
   unsigned char * end_test;

   end_test = (unsigned char *)&seven;
   if (end_test[0] == seven)
      _endian = AFLIB_ENDIAN_LITTLE;
   else
      _endian = AFLIB_ENDIAN_BIG;
}


/*! \brief Returns endian state of this computer platform.
*/
aflib_data_endian
aflibData::getHostEndian() const
{
   return (_endian);
}


void
aflibData::init()
{
   delete [] (unsigned char *)_data;
   _data = NULL;

   allocate();
}

void
aflibData::allocate()
{
   // This will allocate a new _data array without deleting any previous _data.

   _total_length = _config.getChannels() * _length * _byte_inc;
   _data = new unsigned char [_total_length];
   if (_data == NULL)
   {
      cerr << "Error. Out of memory" << endl;
   }
   else
   {
      _initialized = TRUE;
   }
}


/*! \brief This will zero all audio data in this object.
*/
void
aflibData::zeroData()
{
   // This function will cause the data to be zeroed.


   if (_data)
      memset(_data, 0, _total_length);
}


/*! \brief Convert data from one data size to another.

    This function will convert the data in this object to a different
    size. It will rescale the data. If the user passes the data size
    that the data is currently in then nothing will be done.
*/
void
aflibData::convertToSize(aflib_data_size data_size)
{
   register long long data_length, i;


   // IF already in correct format then just return
   if (_config.getSampleSize() == data_size)
      return;

   data_length =  getLength() * _config.getChannels() ;

   // Convert to new format
   switch(_config.getSampleSize())
   {
      case AFLIB_DATA_8S:
      {
         switch (data_size)
         {
            // Convert from 8S to 8U
            case AFLIB_DATA_8U:
            {
               _config.setSampleSize(AFLIB_DATA_8U);
               {
                  char* orig_ptr = (char *)_data;
                  for (i = 0; i < data_length; i++)
                     *orig_ptr++ ^= 0x80;
               }
            }
            break;

            // Convert from 8S to 16S
            case AFLIB_DATA_16S:
            {
               char* old_data = (char  *)_data;

               // Configure new 16 bit data
               _config.setSampleSize(AFLIB_DATA_16S);
               _byte_inc = _config.getBitsPerSample() / 8;

               // allocate new array without destroying old data
               allocate();

               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  short* dest_ptr = (short *)_data;
                  char* orig_ptr = old_data;

                  for (i = 0; i < data_length; i++)
                  {
                     *dest_ptr = LEFT(*orig_ptr++, 8);
                     *dest_ptr++ = swab_short(*dest_ptr);
                  }
               }
               else
               {
                  short* dest_ptr = (short *)_data;
                  char* orig_ptr = old_data;

                  for (i = 0; i < data_length; i++)
                     *dest_ptr++ = LEFT(*orig_ptr++, 8);
               }

               // delete the old orig 8 bit data array
               delete [] old_data;
            }
            break;

            // Convert from 8S to 16U
            case AFLIB_DATA_16U:
            {
               char* old_data = (char  *)_data;

               // Configure new 16 bit data
               _config.setSampleSize(AFLIB_DATA_16U);
               _byte_inc = _config.getBitsPerSample() / 8;

               // allocate new array without destroying old data
               allocate();
               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  short* dest_ptr = (short *)_data;
                  char* orig_ptr = old_data;

                  for (i = 0; i < data_length; i++)
                  {
                     // Scale then toggle sign bit
                     *dest_ptr = LEFT(*orig_ptr++, 8)^0x8000;
                     *dest_ptr++ = swab_short(*dest_ptr);
                  }
               }
               else
               {
                  short* dest_ptr = (short *)_data;
                  char* orig_ptr = old_data;

                  for (i = 0; i < data_length; i++)
                     // Scale then toggle sign bit
                     *dest_ptr++ = LEFT(*orig_ptr++, 8)^0x8000;
               }

               // delete the old orig 8 bit data array
               delete [] old_data;
            }
            break;

            // Convert from 8S to 32S
            case AFLIB_DATA_32S:
            {
               char* old_data = (char  *)_data;

               // Configure new 32 bit data
               _config.setSampleSize(AFLIB_DATA_32S);
               _byte_inc = _config.getBitsPerSample() / 8;

               // allocate new array without destroying old data
               allocate();

               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  int* dest_ptr = (int *)_data;
                  char* orig_ptr = old_data;

                  for (i = 0; i < data_length; i++)
                  {
                     *dest_ptr = LEFT(*orig_ptr++, 24);
                     *dest_ptr++ = swab_int(*dest_ptr);
                  }
               }
               else
               {
                  int* dest_ptr = (int *)_data;
                  char* orig_ptr = old_data;

                  for (i = 0; i < data_length; i++)
                     *dest_ptr++ = LEFT(*orig_ptr++, 24);
               }

               // delete the old orig 8 bit data array
               delete [] old_data;
            }
            break;

            default:
            {
               cerr << "Software Error. Ilegal data size!" << endl;
            }
            break;
         }
      }
      break;
 
      case AFLIB_DATA_8U:
      {
         switch (data_size)
         {
            // Convert from 8U to 8S
            case AFLIB_DATA_8S:
            {
               _config.setSampleSize(AFLIB_DATA_8S);
               {
                  char* orig_ptr = (char *)_data;

                  for (i = 0; i < data_length; i++)
                     // Toggle sign bit
                     *orig_ptr++ ^= 0x80;
               }
            }
            break;

            // Convert from 8U to 16S
            case AFLIB_DATA_16S:
            {
               char* old_data = ( char  *)_data;

               // Configure new 16 bit data
               _config.setSampleSize(AFLIB_DATA_16S);
               _byte_inc = _config.getBitsPerSample() / 8;

               // allocate new array without destroying old data
               allocate();

               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  char* orig_ptr = old_data;
                  short* dest_ptr = (short *)_data;

                  for (i = 0; i < data_length; i++)
                  {
                     *dest_ptr = LEFT(*orig_ptr++, 8)^0x8000 ;
                     *dest_ptr++ = swab_short(*dest_ptr);
                  }
               }
               else
               {
                  char* orig_ptr = old_data;
                  short* dest_ptr = (short *)_data;

                  for (i = 0; i < data_length; i++)
                     *dest_ptr++ = LEFT(*orig_ptr++, 8)^0x8000 ;
               }

               // delete the old orig 8 bit data array
               delete [] old_data;
            }
            break;

            // Convert from 8U to 16U
            case AFLIB_DATA_16U:
            {
               unsigned char* old_data = (unsigned char  *)_data;

               // Configure new 16 bit data
               _config.setSampleSize(AFLIB_DATA_16U);
               _byte_inc = _config.getBitsPerSample() / 8;

               // allocate new array without destroying old data
               allocate();

               {
                  // IF different endians then swap bytes
                  if (_config.getDataEndian() != getHostEndian())
                  {
                     unsigned short* dest_ptr = ( unsigned short *)_data;
                     unsigned char* orig_ptr = old_data;

                     for (i = 0; i < data_length; i++)
                     {
                        *dest_ptr = LEFT(*orig_ptr++, 8);
                        *dest_ptr++ = swab_short(*dest_ptr);
                     }
                  }
                  else
                  {
                     unsigned short* dest_ptr = ( unsigned short *)_data;
                     unsigned char* orig_ptr = old_data;

                     for (i = 0; i < data_length; i++)
                        *dest_ptr++ = LEFT(*orig_ptr++, 8);
                  }
               }

               // delete the old orig 8 bit data array
               delete [] old_data;
            }
            break;

            // Convert from 8U to 32S
            case AFLIB_DATA_32S:
            {
               char* old_data = ( char  *)_data;

               // Configure new 32 bit data
               _config.setSampleSize(AFLIB_DATA_32S);
               _byte_inc = _config.getBitsPerSample() / 8;

               // allocate new array without destroying old data
               allocate();

               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  char* orig_ptr = old_data;
                  int* dest_ptr = (int*)_data;

                  for (i = 0; i < data_length; i++)
                  {
                     *dest_ptr = LEFT(*orig_ptr++, 24)^0x80000000 ;
                     *dest_ptr++ = swab_int(*dest_ptr);
                  }
               }
               else
               {
                  char* orig_ptr = old_data;
                  int* dest_ptr = (int*)_data;

                  for (i = 0; i < data_length; i++)
                     *dest_ptr++ = LEFT(*orig_ptr++, 24)^0x80000000 ;
               }

               // delete the old orig 8 bit data array
               delete [] old_data;
            }
            break;

            default:
            {
               cerr << "Software Error. Ilegal data size!" << endl;
            }
            break;
         }
      }
      break;
 
      case AFLIB_DATA_16S:
      {
         switch (data_size)
         {
            // Convert from 16S to 8S
            // Scale to 8-bit
            case AFLIB_DATA_8S:
            {
               // IF different endians then swap bytes
         	   if (_config.getDataEndian() != getHostEndian())
               {
                  {
   	           	     short* orig_ptr = ( short *)_data;
                     char* dest_ptr = ( char *)orig_ptr;

                     for (i = 0; i < data_length; i++)
                     {
                        *orig_ptr = swab_short(*orig_ptr);
                        *dest_ptr++ = RIGHT(*orig_ptr++, 8);
                     }
                  }
               }
               else
               {
                  short* orig_ptr = ( short *)_data;
                  char* dest_ptr = ( char *)orig_ptr;

                  for (i = 0; i < data_length; i++)
                     *dest_ptr++ = RIGHT(*orig_ptr++, 8);
               }

               _config.setSampleSize(AFLIB_DATA_8S);
               _byte_inc = _config.getBitsPerSample() / 8;
               _total_length = _config.getChannels() * _length * _byte_inc;
            }
            break;

            // Convert from 16S to 8U
            // Scale to 8-bit and toggle sign bit
            case AFLIB_DATA_8U:
            {
      	       // IF different endians then swap bytes
         	   if (_config.getDataEndian() != getHostEndian())
               {
                  short* orig_ptr = ( short *)_data;
                  char* dest_ptr = ( char *)orig_ptr;

                  for (i = 0; i < data_length; i++)
                  {
                     *orig_ptr = swab_short(*orig_ptr);