juce/source/src/audio/dsp/juce_AudioDataConverters.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_AudioDataConverters.h"
  31
  32
  33 //==============================================================================
  34 void AudioDataConverters::convertFloatToInt16LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
  35 {
  36     const double maxVal = (double) 0x7fff;
  37     char* intData = static_cast <char*> (dest);
  38
  39     if (dest != (void*) source || destBytesPerSample <= 4)
  40     {
  41         for (int i = 0; i < numSamples; ++i)
  42         {
  43             *(uint16*) intData = ByteOrder::swapIfBigEndian ((uint16) (short) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
  44             intData += destBytesPerSample;
  45         }
  46     }
  47     else
  48     {
  49         intData += destBytesPerSample * numSamples;
  50
  51         for (int i = numSamples; --i >= 0;)
  52         {
  53             intData -= destBytesPerSample;
  54             *(uint16*) intData = ByteOrder::swapIfBigEndian ((uint16) (short) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
  55         }
  56     }
  57 }
  58
  59 void AudioDataConverters::convertFloatToInt16BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
  60 {
  61     const double maxVal = (double) 0x7fff;
  62     char* intData = static_cast <char*> (dest);
  63
  64     if (dest != (void*) source || destBytesPerSample <= 4)
  65     {
  66         for (int i = 0; i < numSamples; ++i)
  67         {
  68             *(uint16*) intData = ByteOrder::swapIfLittleEndian ((uint16) (short) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
  69             intData += destBytesPerSample;
  70         }
  71     }
  72     else
  73     {
  74         intData += destBytesPerSample * numSamples;
  75
  76         for (int i = numSamples; --i >= 0;)
  77         {
  78             intData -= destBytesPerSample;
  79             *(uint16*) intData = ByteOrder::swapIfLittleEndian ((uint16) (short) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
  80         }
  81     }
  82 }
  83
  84 void AudioDataConverters::convertFloatToInt24LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
  85 {
  86     const double maxVal = (double) 0x7fffff;
  87     char* intData = static_cast <char*> (dest);
  88
  89     if (dest != (void*) source || destBytesPerSample <= 4)
  90     {
  91         for (int i = 0; i < numSamples; ++i)
  92         {
  93             ByteOrder::littleEndian24BitToChars ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])), intData);
  94             intData += destBytesPerSample;
  95         }
  96     }
  97     else
  98     {
  99         intData += destBytesPerSample * numSamples;
 100
 101         for (int i = numSamples; --i >= 0;)
 102         {
 103             intData -= destBytesPerSample;
 104             ByteOrder::littleEndian24BitToChars ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])), intData);
 105         }
 106     }
 107 }
 108
 109 void AudioDataConverters::convertFloatToInt24BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
 110 {
 111     const double maxVal = (double) 0x7fffff;
 112     char* intData = static_cast <char*> (dest);
 113
 114     if (dest != (void*) source || destBytesPerSample <= 4)
 115     {
 116         for (int i = 0; i < numSamples; ++i)
 117         {
 118             ByteOrder::bigEndian24BitToChars ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])), intData);
 119             intData += destBytesPerSample;
 120         }
 121     }
 122     else
 123     {
 124         intData += destBytesPerSample * numSamples;
 125
 126         for (int i = numSamples; --i >= 0;)
 127         {
 128             intData -= destBytesPerSample;
 129             ByteOrder::bigEndian24BitToChars ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])), intData);
 130         }
 131     }
 132 }
 133
 134 void AudioDataConverters::convertFloatToInt32LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
 135 {
 136     const double maxVal = (double) 0x7fffffff;
 137     char* intData = static_cast <char*> (dest);
 138
 139     if (dest != (void*) source || destBytesPerSample <= 4)
 140     {
 141         for (int i = 0; i < numSamples; ++i)
 142         {
 143             *(uint32*)intData = ByteOrder::swapIfBigEndian ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
 144             intData += destBytesPerSample;
 145         }
 146     }
 147     else
 148     {
 149         intData += destBytesPerSample * numSamples;
 150
 151         for (int i = numSamples; --i >= 0;)
 152         {
 153             intData -= destBytesPerSample;
 154             *(uint32*)intData = ByteOrder::swapIfBigEndian ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
 155         }
 156     }
 157 }
 158
 159 void AudioDataConverters::convertFloatToInt32BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
 160 {
 161     const double maxVal = (double) 0x7fffffff;
 162     char* intData = static_cast <char*> (dest);
 163
 164     if (dest != (void*) source || destBytesPerSample <= 4)
 165     {
 166         for (int i = 0; i < numSamples; ++i)
 167         {
 168             *(uint32*)intData = ByteOrder::swapIfLittleEndian ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
 169             intData += destBytesPerSample;
 170         }
 171     }
 172     else
 173     {
 174         intData += destBytesPerSample * numSamples;
 175
 176         for (int i = numSamples; --i >= 0;)
 177         {
 178             intData -= destBytesPerSample;
 179             *(uint32*)intData = ByteOrder::swapIfLittleEndian ((uint32) roundToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
 180         }
 181     }
 182 }
 183
 184 void AudioDataConverters::convertFloatToFloat32LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
 185 {
 186     jassert (dest != (void*) source || destBytesPerSample <= 4); // This op can't be performed on in-place data!
 187
 188     char* d = static_cast <char*> (dest);
 189
 190     for (int i = 0; i < numSamples; ++i)
 191     {
 192         *(float*) d = source[i];
 193
 194        #if JUCE_BIG_ENDIAN
 195         *(uint32*) d = ByteOrder::swap (*(uint32*) d);
 196        #endif
 197
 198         d += destBytesPerSample;
 199     }
 200 }
 201
 202 void AudioDataConverters::convertFloatToFloat32BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
 203 {
 204     jassert (dest != (void*) source || destBytesPerSample <= 4); // This op can't be performed on in-place data!
 205
 206     char* d = static_cast <char*> (dest);
 207
 208     for (int i = 0; i < numSamples; ++i)
 209     {
 210         *(float*) d = source[i];
 211
 212        #if JUCE_LITTLE_ENDIAN
 213         *(uint32*) d = ByteOrder::swap (*(uint32*) d);
 214        #endif
 215
 216         d += destBytesPerSample;
 217     }
 218 }
 219
 220 //==============================================================================
 221 void AudioDataConverters::convertInt16LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 222 {
 223     const float scale = 1.0f / 0x7fff;
 224     const char* intData = static_cast <const char*> (source);
 225
 226     if (source != (void*) dest || srcBytesPerSample >= 4)
 227     {
 228         for (int i = 0; i < numSamples; ++i)
 229         {
 230             dest[i] = scale * (short) ByteOrder::swapIfBigEndian (*(uint16*)intData);
 231             intData += srcBytesPerSample;
 232         }
 233     }
 234     else
 235     {
 236         intData += srcBytesPerSample * numSamples;
 237
 238         for (int i = numSamples; --i >= 0;)
 239         {
 240             intData -= srcBytesPerSample;
 241             dest[i] = scale * (short) ByteOrder::swapIfBigEndian (*(uint16*)intData);
 242         }
 243     }
 244 }
 245
 246 void AudioDataConverters::convertInt16BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 247 {
 248     const float scale = 1.0f / 0x7fff;
 249     const char* intData = static_cast <const char*> (source);
 250
 251     if (source != (void*) dest || srcBytesPerSample >= 4)
 252     {
 253         for (int i = 0; i < numSamples; ++i)
 254         {
 255             dest[i] = scale * (short) ByteOrder::swapIfLittleEndian (*(uint16*)intData);
 256             intData += srcBytesPerSample;
 257         }
 258     }
 259     else
 260     {
 261         intData += srcBytesPerSample * numSamples;
 262
 263         for (int i = numSamples; --i >= 0;)
 264         {
 265             intData -= srcBytesPerSample;
 266             dest[i] = scale * (short) ByteOrder::swapIfLittleEndian (*(uint16*)intData);
 267         }
 268     }
 269 }
 270
 271 void AudioDataConverters::convertInt24LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 272 {
 273     const float scale = 1.0f / 0x7fffff;
 274     const char* intData = static_cast <const char*> (source);
 275
 276     if (source != (void*) dest || srcBytesPerSample >= 4)
 277     {
 278         for (int i = 0; i < numSamples; ++i)
 279         {
 280             dest[i] = scale * (short) ByteOrder::littleEndian24Bit (intData);
 281             intData += srcBytesPerSample;
 282         }
 283     }
 284     else
 285     {
 286         intData += srcBytesPerSample * numSamples;
 287
 288         for (int i = numSamples; --i >= 0;)
 289         {
 290             intData -= srcBytesPerSample;
 291             dest[i] = scale * (short) ByteOrder::littleEndian24Bit (intData);
 292         }
 293     }
 294 }
 295
 296 void AudioDataConverters::convertInt24BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 297 {
 298     const float scale = 1.0f / 0x7fffff;
 299     const char* intData = static_cast <const char*> (source);
 300
 301     if (source != (void*) dest || srcBytesPerSample >= 4)
 302     {
 303         for (int i = 0; i < numSamples; ++i)
 304         {
 305             dest[i] = scale * (short) ByteOrder::bigEndian24Bit (intData);
 306             intData += srcBytesPerSample;
 307         }
 308     }
 309     else
 310     {
 311         intData += srcBytesPerSample * numSamples;
 312
 313         for (int i = numSamples; --i >= 0;)
 314         {
 315             intData -= srcBytesPerSample;
 316             dest[i] = scale * (short) ByteOrder::bigEndian24Bit (intData);
 317         }
 318     }
 319 }
 320
 321 void AudioDataConverters::convertInt32LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 322 {
 323     const float scale = 1.0f / 0x7fffffff;
 324     const char* intData = static_cast <const char*> (source);
 325
 326     if (source != (void*) dest || srcBytesPerSample >= 4)
 327     {
 328         for (int i = 0; i < numSamples; ++i)
 329         {
 330             dest[i] = scale * (int) ByteOrder::swapIfBigEndian (*(uint32*) intData);
 331             intData += srcBytesPerSample;
 332         }
 333     }
 334     else
 335     {
 336         intData += srcBytesPerSample * numSamples;
 337
 338         for (int i = numSamples; --i >= 0;)
 339         {
 340             intData -= srcBytesPerSample;
 341             dest[i] = scale * (int) ByteOrder::swapIfBigEndian (*(uint32*) intData);
 342         }
 343     }
 344 }
 345
 346 void AudioDataConverters::convertInt32BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 347 {
 348     const float scale = 1.0f / 0x7fffffff;
 349     const char* intData = static_cast <const char*> (source);
 350
 351     if (source != (void*) dest || srcBytesPerSample >= 4)
 352     {
 353         for (int i = 0; i < numSamples; ++i)
 354         {
 355             dest[i] = scale * (int) ByteOrder::swapIfLittleEndian (*(uint32*) intData);
 356             intData += srcBytesPerSample;
 357         }
 358     }
 359     else
 360     {
 361         intData += srcBytesPerSample * numSamples;
 362
 363         for (int i = numSamples; --i >= 0;)
 364         {
 365             intData -= srcBytesPerSample;
 366             dest[i] = scale * (int) ByteOrder::swapIfLittleEndian (*(uint32*) intData);
 367         }
 368     }
 369 }
 370
 371 void AudioDataConverters::convertFloat32LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 372 {
 373     const char* s = static_cast <const char*> (source);
 374
 375     for (int i = 0; i < numSamples; ++i)
 376     {
 377         dest[i] = *(float*)s;
 378
 379        #if JUCE_BIG_ENDIAN
 380         uint32* const d = (uint32*) (dest + i);
 381         *d = ByteOrder::swap (*d);
 382        #endif
 383
 384         s += srcBytesPerSample;
 385     }
 386 }
 387
 388 void AudioDataConverters::convertFloat32BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
 389 {
 390     const char* s = static_cast <const char*> (source);
 391
 392     for (int i = 0; i < numSamples; ++i)
 393     {
 394         dest[i] = *(float*)s;
 395
 396        #if JUCE_LITTLE_ENDIAN
 397         uint32* const d = (uint32*) (dest + i);
 398         *d = ByteOrder::swap (*d);
 399        #endif
 400
 401         s += srcBytesPerSample;
 402     }
 403 }
 404
 405
 406 //==============================================================================
 407 void AudioDataConverters::convertFloatToFormat (const DataFormat destFormat,
 408                                                 const float* const source,
 409                                                 void* const dest,
 410                                                 const int numSamples)
 411 {
 412     switch (destFormat)
 413     {
 414         case int16LE:       convertFloatToInt16LE   (source, dest, numSamples); break;
 415         case int16BE:       convertFloatToInt16BE   (source, dest, numSamples); break;
 416         case int24LE:       convertFloatToInt24LE   (source, dest, numSamples); break;
 417         case int24BE:       convertFloatToInt24BE   (source, dest, numSamples); break;
 418         case int32LE:       convertFloatToInt32LE   (source, dest, numSamples); break;
 419         case int32BE:       convertFloatToInt32BE   (source, dest, numSamples); break;
 420         case float32LE:     convertFloatToFloat32LE (source, dest, numSamples); break;
 421         case float32BE:     convertFloatToFloat32BE (source, dest, numSamples); break;
 422         default:            jassertfalse; break;
 423     }
 424 }
 425
 426 void AudioDataConverters::convertFormatToFloat (const DataFormat sourceFormat,
 427                                                 const void* const source,
 428                                                 float* const dest,
 429                                                 const int numSamples)
 430 {
 431     switch (sourceFormat)
 432     {
 433         case int16LE:       convertInt16LEToFloat   (source, dest, numSamples); break;
 434         case int16BE:       convertInt16BEToFloat   (source, dest, numSamples); break;
 435         case int24LE:       convertInt24LEToFloat   (source, dest, numSamples); break;
 436         case int24BE:       convertInt24BEToFloat   (source, dest, numSamples); break;
 437         case int32LE:       convertInt32LEToFloat   (source, dest, numSamples); break;
 438         case int32BE:       convertInt32BEToFloat   (source, dest, numSamples); break;
 439         case float32LE:     convertFloat32LEToFloat (source, dest, numSamples); break;
 440         case float32BE:     convertFloat32BEToFloat (source, dest, numSamples); break;
 441         default:            jassertfalse; break;
 442     }
 443 }
 444
 445 //==============================================================================
 446 void AudioDataConverters::interleaveSamples (const float** const source,
 447                                              float* const dest,
 448                                              const int numSamples,
 449                                              const int numChannels)
 450 {
 451     for (int chan = 0; chan < numChannels; ++chan)
 452     {
 453         int i = chan;
 454         const float* src = source [chan];
 455
 456         for (int j = 0; j < numSamples; ++j)
 457         {
 458             dest [i] = src [j];
 459             i += numChannels;
 460         }
 461     }
 462 }
 463
 464 void AudioDataConverters::deinterleaveSamples (const float* const source,
 465                                                float** const dest,
 466                                                const int numSamples,
 467                                                const int numChannels)
 468 {
 469     for (int chan = 0; chan < numChannels; ++chan)
 470     {
 471         int i = chan;
 472         float* dst = dest [chan];
 473
 474         for (int j = 0; j < numSamples; ++j)
 475         {
 476             dst [j] = source [i];
 477             i += numChannels;
 478         }
 479     }
 480 }
 481
 482
 483 //==============================================================================
 484 #if JUCE_UNIT_TESTS
 485
 486 #include "../../utilities/juce_UnitTest.h"
 487 #include "../../maths/juce_Random.h"
 488
 489 class AudioConversionTests  : public UnitTest
 490 {
 491 public:
 492     AudioConversionTests() : UnitTest ("Audio data conversion") {}
 493
 494     template <class F1, class E1, class F2, class E2>
 495     struct Test5
 496     {
 497         static void test (UnitTest& unitTest)
 498         {
 499             test (unitTest, false);
 500             test (unitTest, true);
 501         }
 502
 503         static void test (UnitTest& unitTest, bool inPlace)
 504         {
 505             const int numSamples = 2048;
 506             int32 original [numSamples], converted [numSamples], reversed [numSamples];
 507
 508             {
 509                 AudioData::Pointer<F1, E1, AudioData::NonInterleaved, AudioData::NonConst> d (original);
 510                 bool clippingFailed = false;
 511
 512                 for (int i = 0; i < numSamples / 2; ++i)
 513                 {
 514                     d.setAsFloat (Random::getSystemRandom().nextFloat() * 2.2f - 1.1f);
 515
 516                     if (! d.isFloatingPoint())
 517                         clippingFailed = d.getAsFloat() > 1.0f || d.getAsFloat() < -1.0f || clippingFailed;
 518
 519                     ++d;
 520                     d.setAsInt32 (Random::getSystemRandom().nextInt());
 521                     ++d;
 522                 }
 523
 524                 unitTest.expect (! clippingFailed);
 525             }
 526
 527             // convert data from the source to dest format..
 528             ScopedPointer<AudioData::Converter> conv (new AudioData::ConverterInstance <AudioData::Pointer<F1, E1, AudioData::NonInterleaved, AudioData::Const>,
 529                                                                                         AudioData::Pointer<F2, E2, AudioData::NonInterleaved, AudioData::NonConst> >());
 530             conv->convertSamples (inPlace ? reversed : converted, original, numSamples);
 531
 532             // ..and back again..
 533             conv = new AudioData::ConverterInstance <AudioData::Pointer<F2, E2, AudioData::NonInterleaved, AudioData::Const>,
 534                                                      AudioData::Pointer<F1, E1, AudioData::NonInterleaved, AudioData::NonConst> >();
 535             if (! inPlace)
 536                 zeromem (reversed, sizeof (reversed));
 537
 538             conv->convertSamples (reversed, inPlace ? reversed : converted, numSamples);
 539
 540             {
 541                 int biggestDiff = 0;
 542                 AudioData::Pointer<F1, E1, AudioData::NonInterleaved, AudioData::Const> d1 (original);
 543                 AudioData::Pointer<F1, E1, AudioData::NonInterleaved, AudioData::Const> d2 (reversed);
 544
 545                 const int errorMargin = 2 * AudioData::Pointer<F1, E1, AudioData::NonInterleaved, AudioData::Const>::get32BitResolution()
 546                                             + AudioData::Pointer<F2, E2, AudioData::NonInterleaved, AudioData::Const>::get32BitResolution();
 547
 548                 for (int i = 0; i < numSamples; ++i)
 549                 {
 550                     biggestDiff = jmax (biggestDiff, std::abs (d1.getAsInt32() - d2.getAsInt32()));
 551                     ++d1;
 552                     ++d2;
 553                 }
 554
 555                 unitTest.expect (biggestDiff <= errorMargin);
 556             }
 557         }
 558     };
 559
 560     template <class F1, class E1, class FormatType>
 561     struct Test3
 562     {
 563         static void test (UnitTest& unitTest)
 564         {
 565             Test5 <F1, E1, FormatType, AudioData::BigEndian>::test (unitTest);
 566             Test5 <F1, E1, FormatType, AudioData::LittleEndian>::test (unitTest);
 567         }
 568     };
 569
 570     template <class FormatType, class Endianness>
 571     struct Test2
 572     {
 573         static void test (UnitTest& unitTest)
 574         {
 575             Test3 <FormatType, Endianness, AudioData::Int8>::test (unitTest);
 576             Test3 <FormatType, Endianness, AudioData::UInt8>::test (unitTest);
 577             Test3 <FormatType, Endianness, AudioData::Int16>::test (unitTest);
 578             Test3 <FormatType, Endianness, AudioData::Int24>::test (unitTest);
 579             Test3 <FormatType, Endianness, AudioData::Int32>::test (unitTest);
 580             Test3 <FormatType, Endianness, AudioData::Float32>::test (unitTest);
 581         }
 582     };
 583
 584     template <class FormatType>
 585     struct Test1
 586     {
 587         static void test (UnitTest& unitTest)
 588         {
 589             Test2 <FormatType, AudioData::BigEndian>::test (unitTest);
 590             Test2 <FormatType, AudioData::LittleEndian>::test (unitTest);
 591         }
 592     };
 593
 594     void runTest()
 595     {
 596         beginTest ("Round-trip conversion: Int8");
 597         Test1 <AudioData::Int8>::test (*this);
 598         beginTest ("Round-trip conversion: Int16");
 599         Test1 <AudioData::Int16>::test (*this);
 600         beginTest ("Round-trip conversion: Int24");
 601         Test1 <AudioData::Int24>::test (*this);
 602         beginTest ("Round-trip conversion: Int32");
 603         Test1 <AudioData::Int32>::test (*this);
 604         beginTest ("Round-trip conversion: Float32");
 605         Test1 <AudioData::Float32>::test (*this);
 606     }
 607 };
 608
 609 static AudioConversionTests audioConversionUnitTests;
 610
 611 #endif
 612
 613
 614 END_JUCE_NAMESPACE