aflibdata.cc

一个共享源码的音频库2

                     *dest_ptr++ = RIGHT(*orig_ptr++, 8)^0x80;
                  }
               }
               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)^0x80;
               }

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

            // Convert 16S to 16U
            // Toggle sign bit
            case AFLIB_DATA_16U:
            {
               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  short* orig_ptr = ( short *)_data;

                  for (i = 0; i < data_length; i++)
                  {
                     *orig_ptr = swab_short(*orig_ptr);
                     *orig_ptr ^= 0x8000;
                     *orig_ptr = swab_short(*orig_ptr);
                     orig_ptr++;
                     // Maybe just this one will work faster
                     // *orig_ptr++ = ^ 0x0080;
                  }
               }
               else
               {
                  short* orig_ptr = ( short *)_data;

                  for (i = 0; i < data_length; i++)
                     *orig_ptr++ ^= 0x8000;
               }

               _config.setSampleSize(AFLIB_DATA_16U);
            }
            break;

            // Convert from 16S to 32S
            // Scale to 32-bit
            case AFLIB_DATA_32S:
            {
               short* old_data = (short  *)_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;
                  short* orig_ptr = old_data;

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

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

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

            default:
            {
               cerr << "Software Error. Ilegal data size!" << endl;
            }
            break;
         }
      }
      break;
 
      case AFLIB_DATA_16U:
      {
         switch (data_size)
         {
            // Convert from 16U to 8S
            // Scale to 8-bit and toggle sign bit
            case AFLIB_DATA_8S:
            {
               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)^0x80;
                  }
               }
               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)^0x80;
               }

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

            // Convert from 16U to 8U
            // Scale to 8-bit
            case AFLIB_DATA_8U:
            {
               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_8U);
               _byte_inc = _config.getBitsPerSample() / 8;
               _total_length = _config.getChannels() * _length * _byte_inc;
            }
            break;

            // Convert 16U to 16S
            // Toggle sign bit
            case AFLIB_DATA_16S:
            {
               if (_config.getDataEndian() != getHostEndian())
               {
                  short* orig_ptr = (short *)_data;

                  for (i = 0; i < data_length; i++)
                  {
                     *orig_ptr = swab_short(*orig_ptr);
                     *orig_ptr ^= 0x8000;
                     *orig_ptr = swab_short(*orig_ptr);
                     orig_ptr++;
                     // Maybe just this one will work faster
                     // *orig_ptr++ = ^ 0x0080;
                  }
               }
               else
               {
                  short* orig_ptr = (short *)_data;

                  for (i = 0; i < data_length; i++)
                     *orig_ptr++ ^= 0x8000;
               }

               _config.setSampleSize(AFLIB_DATA_16S);
            }
            break;

            // Convert 16U to 32S
            // Toggle sign bit
            case AFLIB_DATA_32S:
            {
               unsigned short * old_data = (unsigned short *)_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 (_config.getDataEndian() != getHostEndian())
               {
                  unsigned short * orig_ptr = old_data;
                  int * dest_ptr = (int *)_data;

                  for (i = 0; i < data_length; i++)
                  {
                     /* TBD no I need to swab orig_ptr too ? */
                     *dest_ptr = LEFT(*orig_ptr++, 16)^0x80000000 ;
                     *dest_ptr++ = swab_int(*dest_ptr);
                  }
               }
               else
               {
                  unsigned short * orig_ptr = old_data;
                  int * dest_ptr = (int *)_data;

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

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

            default:
            {
               cerr << "Software Error. Ilegal data size!" << endl;
            }
            break;
         }
      }
      break;

      case AFLIB_DATA_32S:
      {
         switch (data_size)
         {
            case AFLIB_DATA_8S:
            {
               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  {
                     int * orig_ptr = ( int *)_data;
                     char* dest_ptr = ( char *)orig_ptr;

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

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

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

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

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

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

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

            case AFLIB_DATA_16S:
            {
               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  {
                     int * orig_ptr = ( int *)_data;
                     short* dest_ptr = ( short *)orig_ptr;

                     for (i = 0; i < data_length; i++)
                     {
                        *orig_ptr = swab_int(*orig_ptr);
                        *dest_ptr++ = RIGHT(*orig_ptr++, 16);
                     }
                  }
               }
               else
               {
                  int* orig_ptr = ( int *)_data;
                  short* dest_ptr = ( short *)orig_ptr;

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

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

            case AFLIB_DATA_16U:
            {
               // IF different endians then swap bytes
               if (_config.getDataEndian() != getHostEndian())
               {
                  int* orig_ptr = ( int *)_data;
                  short* dest_ptr = ( short *)orig_ptr;

                  for (i = 0; i < data_length; i++)
                  {
                     *orig_ptr = swab_int(*orig_ptr);
                     *dest_ptr++ = RIGHT(*orig_ptr++, 16)^0x8000;
                  }
               }
               else
               {
                  int* orig_ptr = ( int *)_data;
                  short* dest_ptr = ( short *)orig_ptr;

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

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

            default:
            {
               cerr << "Software Error. Ilegal data size!" << endl;
            }
            break;
         }
      }
      break;
 
      default:
      {
         cerr << "Software Error. Ilegal data size!" << endl;
      }
      break;
   }
}


/*! \brief Converts data from one endian format to another.

    This function will convert the data in this object to a different
    endian layout. If the user passes the endian layout
    that the data is currently in then nothing will be done.
*/
void
aflibData::convertToEndian(aflib_data_endian endian)
{
   // IF already in correct format then just return
   if (_config.getDataEndian() == endian)
      return;

   switch(_config.getSampleSize())
   {
      // Endian does not affect this size
      case AFLIB_DATA_8S:
      case AFLIB_DATA_8U:
      {
      }
      break;

      case AFLIB_DATA_16S:
      case AFLIB_DATA_16U:
      {
         long long data_length, i;
         short* orig_ptr = (short *)_data;

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

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

      case AFLIB_DATA_32S:
      {
         long long data_length, i;
         int * orig_ptr = (int *)_data;

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

         for (i = 0; i < data_length; i++)
            *orig_ptr++ = swab_int(*orig_ptr);
      }

      default:
      {
         cerr << "Software Error. Ilegal data size!" << endl;
      }
      break;
   }

   if (endian == AFLIB_ENDIAN_LITTLE)
      _config.setDataEndian(AFLIB_ENDIAN_BIG);
   else
      _config.setDataEndian(AFLIB_ENDIAN_LITTLE);
}