falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4196 Commits
16 Branches
275MB
Tree: d28fafb840
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd28fafb840'
${ noResults }
Carla/source/modules/water/audiocodecs/WavAudioFormat.cpp

977 lines
44KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the Water library.

  5.    Copyright (c) 2015 ROLI Ltd.

  6.    Copyright (C) 2018 Filipe Coelho <falktx@falktx.com>

  7. 

  8.    Permission is granted to use this software under the terms of either:

  9.    a) the GPL v2 (or any later version)

  10.    b) the Affero GPL v3

  11. 

  12.    Details of these licenses can be found at: www.gnu.org/licenses

  13. 

  14.    Water 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. 

  21. #include "WavAudioFormat.h"

  22. 

  23. #include "../audioformat/AudioFormatReader.h"

  24. #include "../memory/ByteOrder.h"

  25. #include "../memory/MemoryBlock.h"

  26. #include "../streams/InputStream.h"

  27. #include "../streams/MemoryOutputStream.h"

  28. #include "../xml/XmlDocument.h"

  29. #include "../xml/XmlElement.h"

  30. 

  31. namespace water {

  32. 

  33. static const char* const wavFormatName = "WAV file";

  34. 

  35. //==============================================================================

  36. const char* const WavAudioFormat::bwavDescription      = "bwav description";

  37. const char* const WavAudioFormat::bwavOriginator       = "bwav originator";

  38. const char* const WavAudioFormat::bwavOriginatorRef    = "bwav originator ref";

  39. const char* const WavAudioFormat::bwavOriginationDate  = "bwav origination date";

  40. const char* const WavAudioFormat::bwavOriginationTime  = "bwav origination time";

  41. const char* const WavAudioFormat::bwavTimeReference    = "bwav time reference";

  42. const char* const WavAudioFormat::bwavCodingHistory    = "bwav coding history";

  43. 

  44. #if 0

  45. StringPairArray WavAudioFormat::createBWAVMetadata (const String& description,

  46.                                                     const String& originator,

  47.                                                     const String& originatorRef,

  48.                                                     Time date,

  49.                                                     const int64 timeReferenceSamples,

  50.                                                     const String& codingHistory)

  51. {

  52.     StringPairArray m;

  53. 

  54.     m.set (bwavDescription, description);

  55.     m.set (bwavOriginator, originator);

  56.     m.set (bwavOriginatorRef, originatorRef);

  57.     m.set (bwavOriginationDate, date.formatted ("%Y-%m-%d"));

  58.     m.set (bwavOriginationTime, date.formatted ("%H:%M:%S"));

  59.     m.set (bwavTimeReference, String (timeReferenceSamples));

  60.     m.set (bwavCodingHistory, codingHistory);

  61. 

  62.     return m;

  63. }

  64. #endif

  65. 

  66. const char* const WavAudioFormat::acidOneShot          = "acid one shot";

  67. const char* const WavAudioFormat::acidRootSet          = "acid root set";

  68. const char* const WavAudioFormat::acidStretch          = "acid stretch";

  69. const char* const WavAudioFormat::acidDiskBased        = "acid disk based";

  70. const char* const WavAudioFormat::acidizerFlag         = "acidizer flag";

  71. const char* const WavAudioFormat::acidRootNote         = "acid root note";

  72. const char* const WavAudioFormat::acidBeats            = "acid beats";

  73. const char* const WavAudioFormat::acidDenominator      = "acid denominator";

  74. const char* const WavAudioFormat::acidNumerator        = "acid numerator";

  75. const char* const WavAudioFormat::acidTempo            = "acid tempo";

  76. 

  77. const char* const WavAudioFormat::riffInfoArchivalLocation      = "IARL";

  78. const char* const WavAudioFormat::riffInfoArtist                = "IART";

  79. const char* const WavAudioFormat::riffInfoBaseURL               = "IBSU";

  80. const char* const WavAudioFormat::riffInfoCinematographer       = "ICNM";

  81. const char* const WavAudioFormat::riffInfoComment               = "CMNT";

  82. const char* const WavAudioFormat::riffInfoComments              = "COMM";

  83. const char* const WavAudioFormat::riffInfoCommissioned          = "ICMS";

  84. const char* const WavAudioFormat::riffInfoCopyright             = "ICOP";

  85. const char* const WavAudioFormat::riffInfoCostumeDesigner       = "ICDS";

  86. const char* const WavAudioFormat::riffInfoCountry               = "ICNT";

  87. const char* const WavAudioFormat::riffInfoCropped               = "ICRP";

  88. const char* const WavAudioFormat::riffInfoDateCreated           = "ICRD";

  89. const char* const WavAudioFormat::riffInfoDateTimeOriginal      = "IDIT";

  90. const char* const WavAudioFormat::riffInfoDefaultAudioStream    = "ICAS";

  91. const char* const WavAudioFormat::riffInfoDimension             = "IDIM";

  92. const char* const WavAudioFormat::riffInfoDirectory             = "DIRC";

  93. const char* const WavAudioFormat::riffInfoDistributedBy         = "IDST";

  94. const char* const WavAudioFormat::riffInfoDotsPerInch           = "IDPI";

  95. const char* const WavAudioFormat::riffInfoEditedBy              = "IEDT";

  96. const char* const WavAudioFormat::riffInfoEighthLanguage        = "IAS8";

  97. const char* const WavAudioFormat::riffInfoEncodedBy             = "CODE";

  98. const char* const WavAudioFormat::riffInfoEndTimecode           = "TCDO";

  99. const char* const WavAudioFormat::riffInfoEngineer              = "IENG";

  100. const char* const WavAudioFormat::riffInfoFifthLanguage         = "IAS5";

  101. const char* const WavAudioFormat::riffInfoFirstLanguage         = "IAS1";

  102. const char* const WavAudioFormat::riffInfoFourthLanguage        = "IAS4";

  103. const char* const WavAudioFormat::riffInfoGenre                 = "GENR";

  104. const char* const WavAudioFormat::riffInfoKeywords              = "IKEY";

  105. const char* const WavAudioFormat::riffInfoLanguage              = "LANG";

  106. const char* const WavAudioFormat::riffInfoLength                = "TLEN";

  107. const char* const WavAudioFormat::riffInfoLightness             = "ILGT";

  108. const char* const WavAudioFormat::riffInfoLocation              = "LOCA";

  109. const char* const WavAudioFormat::riffInfoLogoIconURL           = "ILIU";

  110. const char* const WavAudioFormat::riffInfoLogoURL               = "ILGU";

  111. const char* const WavAudioFormat::riffInfoMedium                = "IMED";

  112. const char* const WavAudioFormat::riffInfoMoreInfoBannerImage   = "IMBI";

  113. const char* const WavAudioFormat::riffInfoMoreInfoBannerURL     = "IMBU";

  114. const char* const WavAudioFormat::riffInfoMoreInfoText          = "IMIT";

  115. const char* const WavAudioFormat::riffInfoMoreInfoURL           = "IMIU";

  116. const char* const WavAudioFormat::riffInfoMusicBy               = "IMUS";

  117. const char* const WavAudioFormat::riffInfoNinthLanguage         = "IAS9";

  118. const char* const WavAudioFormat::riffInfoNumberOfParts         = "PRT2";

  119. const char* const WavAudioFormat::riffInfoOrganisation          = "TORG";

  120. const char* const WavAudioFormat::riffInfoPart                  = "PRT1";

  121. const char* const WavAudioFormat::riffInfoProducedBy            = "IPRO";

  122. const char* const WavAudioFormat::riffInfoProductionDesigner    = "IPDS";

  123. const char* const WavAudioFormat::riffInfoProductionStudio      = "ISDT";

  124. const char* const WavAudioFormat::riffInfoRate                  = "RATE";

  125. const char* const WavAudioFormat::riffInfoRated                 = "AGES";

  126. const char* const WavAudioFormat::riffInfoRating                = "IRTD";

  127. const char* const WavAudioFormat::riffInfoRippedBy              = "IRIP";

  128. const char* const WavAudioFormat::riffInfoSecondaryGenre        = "ISGN";

  129. const char* const WavAudioFormat::riffInfoSecondLanguage        = "IAS2";

  130. const char* const WavAudioFormat::riffInfoSeventhLanguage       = "IAS7";

  131. const char* const WavAudioFormat::riffInfoSharpness             = "ISHP";

  132. const char* const WavAudioFormat::riffInfoSixthLanguage         = "IAS6";

  133. const char* const WavAudioFormat::riffInfoSoftware              = "ISFT";

  134. const char* const WavAudioFormat::riffInfoSoundSchemeTitle      = "DISP";

  135. const char* const WavAudioFormat::riffInfoSource                = "ISRC";

  136. const char* const WavAudioFormat::riffInfoSourceFrom            = "ISRF";

  137. const char* const WavAudioFormat::riffInfoStarring_ISTR         = "ISTR";

  138. const char* const WavAudioFormat::riffInfoStarring_STAR         = "STAR";

  139. const char* const WavAudioFormat::riffInfoStartTimecode         = "TCOD";

  140. const char* const WavAudioFormat::riffInfoStatistics            = "STAT";

  141. const char* const WavAudioFormat::riffInfoSubject               = "ISBJ";

  142. const char* const WavAudioFormat::riffInfoTapeName              = "TAPE";

  143. const char* const WavAudioFormat::riffInfoTechnician            = "ITCH";

  144. const char* const WavAudioFormat::riffInfoThirdLanguage         = "IAS3";

  145. const char* const WavAudioFormat::riffInfoTimeCode              = "ISMP";

  146. const char* const WavAudioFormat::riffInfoTitle                 = "INAM";

  147. const char* const WavAudioFormat::riffInfoTrackNumber           = "TRCK";

  148. const char* const WavAudioFormat::riffInfoURL                   = "TURL";

  149. const char* const WavAudioFormat::riffInfoVegasVersionMajor     = "VMAJ";

  150. const char* const WavAudioFormat::riffInfoVegasVersionMinor     = "VMIN";

  151. const char* const WavAudioFormat::riffInfoVersion               = "TVER";

  152. const char* const WavAudioFormat::riffInfoWatermarkURL          = "IWMU";

  153. const char* const WavAudioFormat::riffInfoWrittenBy             = "IWRI";

  154. const char* const WavAudioFormat::riffInfoYear                  = "YEAR";

  155. 

  156. const char* const WavAudioFormat::ISRC                 = "ISRC";

  157. const char* const WavAudioFormat::tracktionLoopInfo    = "tracktion loop info";

  158. 

  159. //==============================================================================

  160. namespace WavFileHelpers

  161. {

  162.     inline int chunkName (const char* const name) noexcept   { return (int) ByteOrder::littleEndianInt (name); }

  163.     inline size_t roundUpSize (size_t sz) noexcept           { return (sz + 3) & ~3u; }

  164. 

  165.     #if _MSVC_VER

  166.      #pragma pack (push, 1)

  167.     #endif

  168. 

  169.     struct BWAVChunk

  170.     {

  171.         char description [256];

  172.         char originator [32];

  173.         char originatorRef [32];

  174.         char originationDate [10];

  175.         char originationTime [8];

  176.         uint32 timeRefLow;

  177.         uint32 timeRefHigh;

  178.         uint16 version;

  179.         uint8 umid[64];

  180.         uint8 reserved[190];

  181.         char codingHistory[1];

  182. 

  183.         void copyTo (StringPairArray& values, const int totalSize) const

  184.         {

  185.             values.set (WavAudioFormat::bwavDescription,     String::fromUTF8 (description,     sizeof (description)));

  186.             values.set (WavAudioFormat::bwavOriginator,      String::fromUTF8 (originator,      sizeof (originator)));

  187.             values.set (WavAudioFormat::bwavOriginatorRef,   String::fromUTF8 (originatorRef,   sizeof (originatorRef)));

  188.             values.set (WavAudioFormat::bwavOriginationDate, String::fromUTF8 (originationDate, sizeof (originationDate)));

  189.             values.set (WavAudioFormat::bwavOriginationTime, String::fromUTF8 (originationTime, sizeof (originationTime)));

  190. 

  191.             const uint32 timeLow  = ByteOrder::swapIfBigEndian (timeRefLow);

  192.             const uint32 timeHigh = ByteOrder::swapIfBigEndian (timeRefHigh);

  193.             const int64 time = (((int64) timeHigh) << 32) + timeLow;

  194. 

  195.             values.set (WavAudioFormat::bwavTimeReference, String (time));

  196.             values.set (WavAudioFormat::bwavCodingHistory,

  197.                         String::fromUTF8 (codingHistory, totalSize - (int) offsetof (BWAVChunk, codingHistory)));

  198.         }

  199. 

  200.     } WATER_PACKED;

  201. 

  202.     //==============================================================================

  203.     struct SMPLChunk

  204.     {

  205.         struct SampleLoop

  206.         {

  207.             uint32 identifier;

  208.             uint32 type; // these are different in AIFF and WAV

  209.             uint32 start;

  210.             uint32 end;

  211.             uint32 fraction;

  212.             uint32 playCount;

  213.         } WATER_PACKED;

  214. 

  215.         uint32 manufacturer;

  216.         uint32 product;

  217.         uint32 samplePeriod;

  218.         uint32 midiUnityNote;

  219.         uint32 midiPitchFraction;

  220.         uint32 smpteFormat;

  221.         uint32 smpteOffset;

  222.         uint32 numSampleLoops;

  223.         uint32 samplerData;

  224.         SampleLoop loops[1];

  225. 

  226.         template <typename NameType>

  227.         static void setValue (StringPairArray& values, NameType name, uint32 val)

  228.         {

  229.             values.set (name, String (ByteOrder::swapIfBigEndian (val)));

  230.         }

  231. 

  232.         static void setValue (StringPairArray& values, int prefix, const char* name, uint32 val)

  233.         {

  234.             setValue (values, "Loop" + String (prefix) + name, val);

  235.         }

  236. 

  237.         void copyTo (StringPairArray& values, const int totalSize) const

  238.         {

  239.             setValue (values, "Manufacturer",      manufacturer);

  240.             setValue (values, "Product",           product);

  241.             setValue (values, "SamplePeriod",      samplePeriod);

  242.             setValue (values, "MidiUnityNote",     midiUnityNote);

  243.             setValue (values, "MidiPitchFraction", midiPitchFraction);

  244.             setValue (values, "SmpteFormat",       smpteFormat);

  245.             setValue (values, "SmpteOffset",       smpteOffset);

  246.             setValue (values, "NumSampleLoops",    numSampleLoops);

  247.             setValue (values, "SamplerData",       samplerData);

  248. 

  249.             for (int i = 0; i < (int) numSampleLoops; ++i)

  250.             {

  251.                 if ((uint8*) (loops + (i + 1)) > ((uint8*) this) + totalSize)

  252.                     break;

  253. 

  254.                 setValue (values, i, "Identifier", loops[i].identifier);

  255.                 setValue (values, i, "Type",       loops[i].type);

  256.                 setValue (values, i, "Start",      loops[i].start);

  257.                 setValue (values, i, "End",        loops[i].end);

  258.                 setValue (values, i, "Fraction",   loops[i].fraction);

  259.                 setValue (values, i, "PlayCount",  loops[i].playCount);

  260.             }

  261.         }

  262. 

  263.         template <typename NameType>

  264.         static uint32 getValue (const StringPairArray& values, NameType name, const char* def)

  265.         {

  266.             return ByteOrder::swapIfBigEndian ((uint32) values.getValue (name, def).getIntValue());

  267.         }

  268. 

  269.         static uint32 getValue (const StringPairArray& values, int prefix, const char* name, const char* def)

  270.         {

  271.             return getValue (values, "Loop" + String (prefix) + name, def);

  272.         }

  273. 

  274.     } WATER_PACKED;

  275. 

  276.     //==============================================================================

  277.     struct InstChunk

  278.     {

  279.         int8 baseNote;

  280.         int8 detune;

  281.         int8 gain;

  282.         int8 lowNote;

  283.         int8 highNote;

  284.         int8 lowVelocity;

  285.         int8 highVelocity;

  286. 

  287.         static void setValue (StringPairArray& values, const char* name, int val)

  288.         {

  289.             values.set (name, String (val));

  290.         }

  291. 

  292.         void copyTo (StringPairArray& values) const

  293.         {

  294.             setValue (values, "MidiUnityNote",  baseNote);

  295.             setValue (values, "Detune",         detune);

  296.             setValue (values, "Gain",           gain);

  297.             setValue (values, "LowNote",        lowNote);

  298.             setValue (values, "HighNote",       highNote);

  299.             setValue (values, "LowVelocity",    lowVelocity);

  300.             setValue (values, "HighVelocity",   highVelocity);

  301.         }

  302. 

  303.         static int8 getValue (const StringPairArray& values, const char* name, const char* def)

  304.         {

  305.             return (int8) values.getValue (name, def).getIntValue();

  306.         }

  307. 

  308.     } WATER_PACKED;

  309. 

  310.     //==============================================================================

  311.     struct CueChunk

  312.     {

  313.         struct Cue

  314.         {

  315.             uint32 identifier;

  316.             uint32 order;

  317.             uint32 chunkID;

  318.             uint32 chunkStart;

  319.             uint32 blockStart;

  320.             uint32 offset;

  321.         } WATER_PACKED;

  322. 

  323.         uint32 numCues;

  324.         Cue cues[1];

  325. 

  326.         static void setValue (StringPairArray& values, int prefix, const char* name, uint32 val)

  327.         {

  328.             values.set ("Cue" + String (prefix) + name, String (ByteOrder::swapIfBigEndian (val)));

  329.         }

  330. 

  331.         void copyTo (StringPairArray& values, const int totalSize) const

  332.         {

  333.             values.set ("NumCuePoints", String (ByteOrder::swapIfBigEndian (numCues)));

  334. 

  335.             for (int i = 0; i < (int) numCues; ++i)

  336.             {

  337.                 if ((uint8*) (cues + (i + 1)) > ((uint8*) this) + totalSize)

  338.                     break;

  339. 

  340.                 setValue (values, i, "Identifier",  cues[i].identifier);

  341.                 setValue (values, i, "Order",       cues[i].order);

  342.                 setValue (values, i, "ChunkID",     cues[i].chunkID);

  343.                 setValue (values, i, "ChunkStart",  cues[i].chunkStart);

  344.                 setValue (values, i, "BlockStart",  cues[i].blockStart);

  345.                 setValue (values, i, "Offset",      cues[i].offset);

  346.             }

  347.         }

  348. 

  349.     } WATER_PACKED;

  350. 

  351.     //==============================================================================

  352.     /** Reads a RIFF List Info chunk from a stream positioned just after the size byte. */

  353.     namespace ListInfoChunk

  354.     {

  355.         static const char* const types[] =

  356.         {

  357.             WavAudioFormat::riffInfoArchivalLocation,

  358.             WavAudioFormat::riffInfoArtist,

  359.             WavAudioFormat::riffInfoBaseURL,

  360.             WavAudioFormat::riffInfoCinematographer,

  361.             WavAudioFormat::riffInfoComment,

  362.             WavAudioFormat::riffInfoComments,

  363.             WavAudioFormat::riffInfoCommissioned,

  364.             WavAudioFormat::riffInfoCopyright,

  365.             WavAudioFormat::riffInfoCostumeDesigner,

  366.             WavAudioFormat::riffInfoCountry,

  367.             WavAudioFormat::riffInfoCropped,

  368.             WavAudioFormat::riffInfoDateCreated,

  369.             WavAudioFormat::riffInfoDateTimeOriginal,

  370.             WavAudioFormat::riffInfoDefaultAudioStream,

  371.             WavAudioFormat::riffInfoDimension,

  372.             WavAudioFormat::riffInfoDirectory,

  373.             WavAudioFormat::riffInfoDistributedBy,

  374.             WavAudioFormat::riffInfoDotsPerInch,

  375.             WavAudioFormat::riffInfoEditedBy,

  376.             WavAudioFormat::riffInfoEighthLanguage,

  377.             WavAudioFormat::riffInfoEncodedBy,

  378.             WavAudioFormat::riffInfoEndTimecode,

  379.             WavAudioFormat::riffInfoEngineer,

  380.             WavAudioFormat::riffInfoFifthLanguage,

  381.             WavAudioFormat::riffInfoFirstLanguage,

  382.             WavAudioFormat::riffInfoFourthLanguage,

  383.             WavAudioFormat::riffInfoGenre,

  384.             WavAudioFormat::riffInfoKeywords,

  385.             WavAudioFormat::riffInfoLanguage,

  386.             WavAudioFormat::riffInfoLength,

  387.             WavAudioFormat::riffInfoLightness,

  388.             WavAudioFormat::riffInfoLocation,

  389.             WavAudioFormat::riffInfoLogoIconURL,

  390.             WavAudioFormat::riffInfoLogoURL,

  391.             WavAudioFormat::riffInfoMedium,

  392.             WavAudioFormat::riffInfoMoreInfoBannerImage,

  393.             WavAudioFormat::riffInfoMoreInfoBannerURL,

  394.             WavAudioFormat::riffInfoMoreInfoText,

  395.             WavAudioFormat::riffInfoMoreInfoURL,

  396.             WavAudioFormat::riffInfoMusicBy,

  397.             WavAudioFormat::riffInfoNinthLanguage,

  398.             WavAudioFormat::riffInfoNumberOfParts,

  399.             WavAudioFormat::riffInfoOrganisation,

  400.             WavAudioFormat::riffInfoPart,

  401.             WavAudioFormat::riffInfoProducedBy,

  402.             WavAudioFormat::riffInfoProductionDesigner,

  403.             WavAudioFormat::riffInfoProductionStudio,

  404.             WavAudioFormat::riffInfoRate,

  405.             WavAudioFormat::riffInfoRated,

  406.             WavAudioFormat::riffInfoRating,

  407.             WavAudioFormat::riffInfoRippedBy,

  408.             WavAudioFormat::riffInfoSecondaryGenre,

  409.             WavAudioFormat::riffInfoSecondLanguage,

  410.             WavAudioFormat::riffInfoSeventhLanguage,

  411.             WavAudioFormat::riffInfoSharpness,

  412.             WavAudioFormat::riffInfoSixthLanguage,

  413.             WavAudioFormat::riffInfoSoftware,

  414.             WavAudioFormat::riffInfoSoundSchemeTitle,

  415.             WavAudioFormat::riffInfoSource,

  416.             WavAudioFormat::riffInfoSourceFrom,

  417.             WavAudioFormat::riffInfoStarring_ISTR,

  418.             WavAudioFormat::riffInfoStarring_STAR,

  419.             WavAudioFormat::riffInfoStartTimecode,

  420.             WavAudioFormat::riffInfoStatistics,

  421.             WavAudioFormat::riffInfoSubject,

  422.             WavAudioFormat::riffInfoTapeName,

  423.             WavAudioFormat::riffInfoTechnician,

  424.             WavAudioFormat::riffInfoThirdLanguage,

  425.             WavAudioFormat::riffInfoTimeCode,

  426.             WavAudioFormat::riffInfoTitle,

  427.             WavAudioFormat::riffInfoTrackNumber,

  428.             WavAudioFormat::riffInfoURL,

  429.             WavAudioFormat::riffInfoVegasVersionMajor,

  430.             WavAudioFormat::riffInfoVegasVersionMinor,

  431.             WavAudioFormat::riffInfoVersion,

  432.             WavAudioFormat::riffInfoWatermarkURL,

  433.             WavAudioFormat::riffInfoWrittenBy,

  434.             WavAudioFormat::riffInfoYear

  435.         };

  436. 

  437.         static bool isMatchingTypeIgnoringCase (const int value, const char* const name) noexcept

  438.         {

  439.             for (int i = 0; i < 4; ++i)

  440.                 if ((uint32) name[i] != CharacterFunctions::toUpperCase ((uint32) ((value >> (i * 8)) & 0xff)))

  441.                     return false;

  442. 

  443.             return true;

  444.         }

  445. 

  446.         static void addToMetadata (StringPairArray& values, InputStream& input, int64 chunkEnd)

  447.         {

  448.             while (input.getPosition() < chunkEnd)

  449.             {

  450.                 const int infoType = input.readInt();

  451. 

  452.                 int64 infoLength = chunkEnd - input.getPosition();

  453. 

  454.                 if (infoLength > 0)

  455.                 {

  456.                     infoLength = jmin (infoLength, (int64) input.readInt());

  457. 

  458.                     if (infoLength <= 0)

  459.                         return;

  460. 

  461.                     for (int i = 0; i < numElementsInArray (types); ++i)

  462.                     {

  463.                         if (isMatchingTypeIgnoringCase (infoType, types[i]))

  464.                         {

  465.                             MemoryBlock mb;

  466.                             input.readIntoMemoryBlock (mb, (ssize_t) infoLength);

  467.                             values.set (types[i], String::createStringFromData ((const char*) mb.getData(),

  468.                                                                                 (int) mb.getSize()));

  469.                             break;

  470.                         }

  471.                     }

  472.                 }

  473.             }

  474.         }

  475.     }

  476. 

  477.     //==============================================================================

  478.     struct AcidChunk

  479.     {

  480.         /** Reads an acid RIFF chunk from a stream positioned just after the size byte. */

  481.         AcidChunk (InputStream& input, size_t length)

  482.         {

  483.             zerostruct (*this);

  484.             input.read (this, (int) jmin (sizeof (*this), length));

  485.         }

  486. 

  487.         AcidChunk (const StringPairArray& values)

  488.         {

  489.             zerostruct (*this);

  490. 

  491.             flags = getFlagIfPresent (values, WavAudioFormat::acidOneShot,   0x01)

  492.                   | getFlagIfPresent (values, WavAudioFormat::acidRootSet,   0x02)

  493.                   | getFlagIfPresent (values, WavAudioFormat::acidStretch,   0x04)

  494.                   | getFlagIfPresent (values, WavAudioFormat::acidDiskBased, 0x08)

  495.                   | getFlagIfPresent (values, WavAudioFormat::acidizerFlag,  0x10);

  496. 

  497.             if (values[WavAudioFormat::acidRootSet].getIntValue() != 0)

  498.                 rootNote = ByteOrder::swapIfBigEndian ((uint16) values[WavAudioFormat::acidRootNote].getIntValue());

  499. 

  500.             numBeats          = ByteOrder::swapIfBigEndian ((uint32) values[WavAudioFormat::acidBeats].getIntValue());

  501.             meterDenominator  = ByteOrder::swapIfBigEndian ((uint16) values[WavAudioFormat::acidDenominator].getIntValue());

  502.             meterNumerator    = ByteOrder::swapIfBigEndian ((uint16) values[WavAudioFormat::acidNumerator].getIntValue());

  503. 

  504.             if (values.containsKey (WavAudioFormat::acidTempo))

  505.                 tempo = swapFloatByteOrder (values[WavAudioFormat::acidTempo].getFloatValue());

  506.         }

  507. 

  508.         MemoryBlock toMemoryBlock() const

  509.         {

  510.             return (flags != 0 || rootNote != 0 || numBeats != 0 || meterDenominator != 0 || meterNumerator != 0)

  511.                       ? MemoryBlock (this, sizeof (*this)) : MemoryBlock();

  512.         }

  513. 

  514.         void addToMetadata (StringPairArray& values) const

  515.         {

  516.             setBoolFlag (values, WavAudioFormat::acidOneShot,   0x01);

  517.             setBoolFlag (values, WavAudioFormat::acidRootSet,   0x02);

  518.             setBoolFlag (values, WavAudioFormat::acidStretch,   0x04);

  519.             setBoolFlag (values, WavAudioFormat::acidDiskBased, 0x08);

  520.             setBoolFlag (values, WavAudioFormat::acidizerFlag,  0x10);

  521. 

  522.             if (flags & 0x02) // root note set

  523.                 values.set (WavAudioFormat::acidRootNote, String (ByteOrder::swapIfBigEndian (rootNote)));

  524. 

  525.             values.set (WavAudioFormat::acidBeats,       String (ByteOrder::swapIfBigEndian (numBeats)));

  526.             values.set (WavAudioFormat::acidDenominator, String (ByteOrder::swapIfBigEndian (meterDenominator)));

  527.             values.set (WavAudioFormat::acidNumerator,   String (ByteOrder::swapIfBigEndian (meterNumerator)));

  528.             values.set (WavAudioFormat::acidTempo,       String (swapFloatByteOrder (tempo)));

  529.         }

  530. 

  531.         void setBoolFlag (StringPairArray& values, const char* name, uint32 mask) const

  532.         {

  533.             values.set (name, (flags & ByteOrder::swapIfBigEndian (mask)) ? "1" : "0");

  534.         }

  535. 

  536.         static uint32 getFlagIfPresent (const StringPairArray& values, const char* name, uint32 flag)

  537.         {

  538.             return values[name].getIntValue() != 0 ? ByteOrder::swapIfBigEndian (flag) : 0;

  539.         }

  540. 

  541.         static float swapFloatByteOrder (const float x) noexcept

  542.         {

  543.            #if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__

  544.             union { uint32 asInt; float asFloat; } n;

  545.             n.asFloat = x;

  546.             n.asInt = ByteOrder::swap (n.asInt);

  547.             return n.asFloat;

  548.            #else

  549.             return x;

  550.            #endif

  551.         }

  552. 

  553.         uint32 flags;

  554.         uint16 rootNote;

  555.         uint16 reserved1;

  556.         float reserved2;

  557.         uint32 numBeats;

  558.         uint16 meterDenominator;

  559.         uint16 meterNumerator;

  560.         float tempo;

  561. 

  562.     } WATER_PACKED;

  563. 

  564.     //==============================================================================

  565.     namespace AXMLChunk

  566.     {

  567.         static void addToMetadata (StringPairArray& destValues, const String& source)

  568.         {

  569.             ScopedPointer<XmlElement> xml (XmlDocument::parse (source));

  570. 

  571.             if (xml != nullptr && xml->hasTagName ("ebucore:ebuCoreMain"))

  572.             {

  573.                 if (XmlElement* xml2 = xml->getChildByName ("ebucore:coreMetadata"))

  574.                 {

  575.                     if (XmlElement* xml3 = xml2->getChildByName ("ebucore:identifier"))

  576.                     {

  577.                         if (XmlElement* xml4 = xml3->getChildByName ("dc:identifier"))

  578.                         {

  579.                             const String ISRCCode (xml4->getAllSubText().fromFirstOccurrenceOf ("ISRC:", false, true));

  580. 

  581.                             if (ISRCCode.isNotEmpty())

  582.                                 destValues.set (WavAudioFormat::ISRC, ISRCCode);

  583.                         }

  584.                     }

  585.                 }

  586.             }

  587.         }

  588.     };

  589. 

  590.     //==============================================================================

  591.     struct ExtensibleWavSubFormat

  592.     {

  593.         uint32 data1;

  594.         uint16 data2;

  595.         uint16 data3;

  596.         uint8  data4[8];

  597. 

  598.         bool operator== (const ExtensibleWavSubFormat& other) const noexcept   { return memcmp (this, &other, sizeof (*this)) == 0; }

  599.         bool operator!= (const ExtensibleWavSubFormat& other) const noexcept   { return ! operator== (other); }

  600. 

  601.     } WATER_PACKED;

  602. 

  603.     static const ExtensibleWavSubFormat pcmFormat       = { 0x00000001, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 } };

  604.     static const ExtensibleWavSubFormat IEEEFloatFormat = { 0x00000003, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 } };

  605.     static const ExtensibleWavSubFormat ambisonicFormat = { 0x00000001, 0x0721, 0x11d3, { 0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00 } };

  606. 

  607.     struct DataSize64Chunk   // chunk ID = 'ds64' if data size > 0xffffffff, 'JUNK' otherwise

  608.     {

  609.         uint32 riffSizeLow;     // low 4 byte size of RF64 block

  610.         uint32 riffSizeHigh;    // high 4 byte size of RF64 block

  611.         uint32 dataSizeLow;     // low 4 byte size of data chunk

  612.         uint32 dataSizeHigh;    // high 4 byte size of data chunk

  613.         uint32 sampleCountLow;  // low 4 byte sample count of fact chunk

  614.         uint32 sampleCountHigh; // high 4 byte sample count of fact chunk

  615.         uint32 tableLength;     // number of valid entries in array 'table'

  616.     } WATER_PACKED;

  617. 

  618.     #if _MSVC_VER

  619.      #pragma pack (pop)

  620.     #endif

  621. }

  622. 

  623. //==============================================================================

  624. class WavAudioFormatReader  : public AudioFormatReader

  625. {

  626. public:

  627.     WavAudioFormatReader (InputStream* const in)

  628.         : AudioFormatReader (in, wavFormatName),

  629.           bwavChunkStart (0),

  630.           bwavSize (0),

  631.           dataLength (0),

  632.           isRF64 (false)

  633.     {

  634.         using namespace WavFileHelpers;

  635.         uint64 len = 0;

  636.         uint64 end = 0;

  637.         int cueNoteIndex = 0;

  638.         int cueLabelIndex = 0;

  639.         int cueRegionIndex = 0;

  640. 

  641.         const int firstChunkType = input->readInt();

  642. 

  643.         if (firstChunkType == chunkName ("RF64"))

  644.         {

  645.             input->skipNextBytes (4); // size is -1 for RF64

  646.             isRF64 = true;

  647.         }

  648.         else if (firstChunkType == chunkName ("RIFF"))

  649.         {

  650.             len = (uint64) (uint32) input->readInt();

  651.             end = len + (uint64) input->getPosition();

  652.         }

  653.         else

  654.         {

  655.             return;

  656.         }

  657. 

  658.         const int64 startOfRIFFChunk = input->getPosition();

  659. 

  660.         if (input->readInt() == chunkName ("WAVE"))

  661.         {

  662.             if (isRF64 && input->readInt() == chunkName ("ds64"))

  663.             {

  664.                 const uint32 length = (uint32) input->readInt();

  665. 

  666.                 if (length < 28)

  667.                     return;

  668. 

  669.                 const int64 chunkEnd = input->getPosition() + length + (length & 1);

  670.                 len = (uint64) input->readInt64();

  671.                 end = len + (uint64) startOfRIFFChunk;

  672.                 dataLength = input->readInt64();

  673.                 input->setPosition (chunkEnd);

  674.             }

  675. 

  676.             while ((uint64) input->getPosition() < end && ! input->isExhausted())

  677.             {

  678.                 const int chunkType = input->readInt();

  679.                 uint32 length = (uint32) input->readInt();

  680.                 const int64 chunkEnd = input->getPosition() + length + (length & 1);

  681. 

  682.                 if (chunkType == chunkName ("fmt "))

  683.                 {

  684.                     // read the format chunk

  685.                     const unsigned short format = (unsigned short) input->readShort();

  686.                     numChannels = (unsigned int) input->readShort();

  687.                     sampleRate = input->readInt();

  688.                     const int bytesPerSec = input->readInt();

  689.                     input->skipNextBytes (2);

  690.                     bitsPerSample = (unsigned int) (int) input->readShort();

  691. 

  692.                     if (bitsPerSample > 64)

  693.                     {

  694.                         bytesPerFrame = bytesPerSec / (int) sampleRate;

  695.                         bitsPerSample = 8 * (unsigned int) bytesPerFrame / numChannels;

  696.                     }

  697.                     else

  698.                     {

  699.                         bytesPerFrame = numChannels * bitsPerSample / 8;

  700.                     }

  701. 

  702.                     if (format == 3)

  703.                     {

  704.                         usesFloatingPointData = true;

  705.                     }

  706.                     else if (format == 0xfffe /*WAVE_FORMAT_EXTENSIBLE*/)

  707.                     {

  708.                         if (length < 40) // too short

  709.                         {

  710.                             bytesPerFrame = 0;

  711.                         }

  712.                         else

  713.                         {

  714.                             input->skipNextBytes (4); // skip over size and bitsPerSample

  715.                             metadataValues.set ("ChannelMask", String (input->readInt()));

  716. 

  717.                             ExtensibleWavSubFormat subFormat;

  718.                             subFormat.data1 = (uint32) input->readInt();

  719.                             subFormat.data2 = (uint16) input->readShort();

  720.                             subFormat.data3 = (uint16) input->readShort();

  721.                             input->read (subFormat.data4, sizeof (subFormat.data4));

  722. 

  723.                             if (subFormat == IEEEFloatFormat)

  724.                                 usesFloatingPointData = true;

  725.                             else if (subFormat != pcmFormat && subFormat != ambisonicFormat)

  726.                                 bytesPerFrame = 0;

  727.                         }

  728.                     }

  729.                     else if (format != 1)

  730.                     {

  731.                         bytesPerFrame = 0;

  732.                     }

  733.                 }

  734.                 else if (chunkType == chunkName ("data"))

  735.                 {

  736.                     if (! isRF64) // data size is expected to be -1, actual data size is in ds64 chunk

  737.                         dataLength = length;

  738. 

  739.                     dataChunkStart = input->getPosition();

  740.                     lengthInSamples = (bytesPerFrame > 0) ? (dataLength / bytesPerFrame) : 0;

  741.                 }

  742.                 else if (chunkType == chunkName ("bext"))

  743.                 {

  744.                     bwavChunkStart = input->getPosition();

  745.                     bwavSize = length;

  746. 

  747.                     HeapBlock<BWAVChunk> bwav;

  748.                     bwav.calloc (jmax ((size_t) length + 1, sizeof (BWAVChunk)), 1);

  749.                     input->read (bwav, (int) length);

  750.                     bwav->copyTo (metadataValues, (int) length);

  751.                 }

  752.                 else if (chunkType == chunkName ("smpl"))

  753.                 {

  754.                     HeapBlock<SMPLChunk> smpl;

  755.                     smpl.calloc (jmax ((size_t) length + 1, sizeof (SMPLChunk)), 1);

  756.                     input->read (smpl, (int) length);

  757.                     smpl->copyTo (metadataValues, (int) length);

  758.                 }

  759.                 else if (chunkType == chunkName ("inst") || chunkType == chunkName ("INST")) // need to check which...

  760.                 {

  761.                     HeapBlock<InstChunk> inst;

  762.                     inst.calloc (jmax ((size_t) length + 1, sizeof (InstChunk)), 1);

  763.                     input->read (inst, (int) length);

  764.                     inst->copyTo (metadataValues);

  765.                 }

  766.                 else if (chunkType == chunkName ("cue "))

  767.                 {

  768.                     HeapBlock<CueChunk> cue;

  769.                     cue.calloc (jmax ((size_t) length + 1, sizeof (CueChunk)), 1);

  770.                     input->read (cue, (int) length);

  771.                     cue->copyTo (metadataValues, (int) length);

  772.                 }

  773.                 else if (chunkType == chunkName ("axml"))

  774.                 {

  775.                     MemoryBlock axml;

  776.                     input->readIntoMemoryBlock (axml, (ssize_t) length);

  777.                     AXMLChunk::addToMetadata (metadataValues, axml.toString());

  778.                 }

  779.                 else if (chunkType == chunkName ("LIST"))

  780.                 {

  781.                     const int subChunkType = input->readInt();

  782. 

  783.                     if (subChunkType == chunkName ("info") || subChunkType == chunkName ("INFO"))

  784.                     {

  785.                         ListInfoChunk::addToMetadata (metadataValues, *input, chunkEnd);

  786.                     }

  787.                     else if (subChunkType == chunkName ("adtl"))

  788.                     {

  789.                         while (input->getPosition() < chunkEnd)

  790.                         {

  791.                             const int adtlChunkType = input->readInt();

  792.                             const uint32 adtlLength = (uint32) input->readInt();

  793.                             const int64 adtlChunkEnd = input->getPosition() + (adtlLength + (adtlLength & 1));

  794. 

  795.                             if (adtlChunkType == chunkName ("labl") || adtlChunkType == chunkName ("note"))

  796.                             {

  797.                                 String prefix;

  798. 

  799.                                 if (adtlChunkType == chunkName ("labl"))

  800.                                     prefix << "CueLabel" << cueLabelIndex++;

  801.                                 else if (adtlChunkType == chunkName ("note"))

  802.                                     prefix << "CueNote" << cueNoteIndex++;

  803. 

  804.                                 const uint32 identifier = (uint32) input->readInt();

  805.                                 const int stringLength = (int) adtlLength - 4;

  806. 

  807.                                 MemoryBlock textBlock;

  808.                                 input->readIntoMemoryBlock (textBlock, stringLength);

  809. 

  810.                                 metadataValues.set (prefix + "Identifier", String (identifier));

  811.                                 metadataValues.set (prefix + "Text", textBlock.toString());

  812.                             }

  813.                             else if (adtlChunkType == chunkName ("ltxt"))

  814.                             {

  815.                                 const String prefix ("CueRegion" + String (cueRegionIndex++));

  816.                                 const uint32 identifier     = (uint32) input->readInt();

  817.                                 const uint32 sampleLength   = (uint32) input->readInt();

  818.                                 const uint32 purpose        = (uint32) input->readInt();

  819.                                 const uint16 country        = (uint16) input->readInt();

  820.                                 const uint16 language       = (uint16) input->readInt();

  821.                                 const uint16 dialect        = (uint16) input->readInt();

  822.                                 const uint16 codePage       = (uint16) input->readInt();

  823.                                 const uint32 stringLength   = adtlLength - 20;

  824. 

  825.                                 MemoryBlock textBlock;

  826.                                 input->readIntoMemoryBlock (textBlock, (int) stringLength);

  827. 

  828.                                 metadataValues.set (prefix + "Identifier",   String (identifier));

  829.                                 metadataValues.set (prefix + "SampleLength", String (sampleLength));

  830.                                 metadataValues.set (prefix + "Purpose",      String (purpose));

  831.                                 metadataValues.set (prefix + "Country",      String (country));

  832.                                 metadataValues.set (prefix + "Language",     String (language));

  833.                                 metadataValues.set (prefix + "Dialect",      String (dialect));

  834.                                 metadataValues.set (prefix + "CodePage",     String (codePage));

  835.                                 metadataValues.set (prefix + "Text",         textBlock.toString());

  836.                             }

  837. 

  838.                             input->setPosition (adtlChunkEnd);

  839.                         }

  840.                     }

  841.                 }

  842.                 else if (chunkType == chunkName ("acid"))

  843.                 {

  844.                     AcidChunk (*input, length).addToMetadata (metadataValues);

  845.                 }

  846.                 else if (chunkType == chunkName ("Trkn"))

  847.                 {

  848.                     MemoryBlock tracktion;

  849.                     input->readIntoMemoryBlock (tracktion, (ssize_t) length);

  850.                     metadataValues.set (WavAudioFormat::tracktionLoopInfo, tracktion.toString());

  851.                 }

  852.                 else if (chunkEnd <= input->getPosition())

  853.                 {

  854.                     break;

  855.                 }

  856. 

  857.                 input->setPosition (chunkEnd);

  858.             }

  859.         }

  860. 

  861.         if (cueLabelIndex > 0)          metadataValues.set ("NumCueLabels",    String (cueLabelIndex));

  862.         if (cueNoteIndex > 0)           metadataValues.set ("NumCueNotes",     String (cueNoteIndex));

  863.         if (cueRegionIndex > 0)         metadataValues.set ("NumCueRegions",   String (cueRegionIndex));

  864.         if (metadataValues.size() > 0)  metadataValues.set ("MetaDataSource",  "WAV");

  865.     }

  866. 

  867.     //==============================================================================

  868.     bool readSamples (int** destSamples, int numDestChannels, int startOffsetInDestBuffer,

  869.                       int64 startSampleInFile, int numSamples) override

  870.     {

  871.         clearSamplesBeyondAvailableLength (destSamples, numDestChannels, startOffsetInDestBuffer,

  872.                                            startSampleInFile, numSamples, lengthInSamples);

  873. 

  874.         if (numSamples <= 0)

  875.             return true;

  876. 

  877.         input->setPosition (dataChunkStart + startSampleInFile * bytesPerFrame);

  878. 

  879.         while (numSamples > 0)

  880.         {

  881.             const int tempBufSize = 480 * 3 * 4; // (keep this a multiple of 3)

  882.             char tempBuffer [tempBufSize];

  883. 

  884.             const int numThisTime = jmin (tempBufSize / bytesPerFrame, numSamples);

  885.             const int bytesRead = input->read (tempBuffer, numThisTime * bytesPerFrame);

  886. 

  887.             if (bytesRead < numThisTime * bytesPerFrame)

  888.             {

  889.                 jassert (bytesRead >= 0);

  890.                 zeromem (tempBuffer + bytesRead, (size_t) (numThisTime * bytesPerFrame - bytesRead));

  891.             }

  892. 

  893.             copySampleData (bitsPerSample, usesFloatingPointData,

  894.                             destSamples, startOffsetInDestBuffer, numDestChannels,

  895.                             tempBuffer, (int) numChannels, numThisTime);

  896. 

  897.             startOffsetInDestBuffer += numThisTime;

  898.             numSamples -= numThisTime;

  899.         }

  900. 

  901.         return true;

  902.     }

  903. 

  904.     static void copySampleData (unsigned int bitsPerSample, const bool usesFloatingPointData,

  905.                                 int* const* destSamples, int startOffsetInDestBuffer, int numDestChannels,

  906.                                 const void* sourceData, int numChannels, int numSamples) noexcept

  907.     {

  908.         switch (bitsPerSample)

  909.         {

  910.             case 8:

  911.                 ReadHelper<AudioData::Int32, AudioData::UInt8, AudioData::LittleEndian>::read (destSamples, startOffsetInDestBuffer, numDestChannels, sourceData, numChannels, numSamples);

  912.                 break;

  913.             case 16:

  914.                 ReadHelper<AudioData::Int32, AudioData::Int16, AudioData::LittleEndian>::read (destSamples, startOffsetInDestBuffer, numDestChannels, sourceData, numChannels, numSamples);

  915.                 break;

  916.             case 24:

  917.                 ReadHelper<AudioData::Int32, AudioData::Int24, AudioData::LittleEndian>::read (destSamples, startOffsetInDestBuffer, numDestChannels, sourceData, numChannels, numSamples);

  918.                 break;

  919.             case 32:

  920.                 if (usesFloatingPointData)

  921.                     ReadHelper<AudioData::Float32, AudioData::Float32, AudioData::LittleEndian>::read (destSamples, startOffsetInDestBuffer, numDestChannels, sourceData, numChannels, numSamples);

  922.                 else

  923.                     ReadHelper<AudioData::Int32,   AudioData::Int32,   AudioData::LittleEndian>::read (destSamples, startOffsetInDestBuffer, numDestChannels, sourceData, numChannels, numSamples);

  924.                 break;

  925.             default:

  926.                 jassertfalse;

  927.                 break;

  928.         }

  929.     }

  930. 

  931.     int64 bwavChunkStart, bwavSize;

  932.     int64 dataChunkStart, dataLength;

  933.     int bytesPerFrame;

  934.     bool isRF64;

  935. 

  936. private:

  937.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (WavAudioFormatReader)

  938. };

  939. 

  940. //==============================================================================

  941. WavAudioFormat::WavAudioFormat()  : AudioFormat (wavFormatName, ".wav .bwf") {}

  942. WavAudioFormat::~WavAudioFormat() {}

  943. 

  944. Array<int> WavAudioFormat::getPossibleSampleRates()

  945. {

  946.     const int rates[] = { 8000, 11025, 12000, 16000, 22050, 32000, 44100,

  947.                           48000, 88200, 96000, 176400, 192000, 352800, 384000 };

  948. 

  949.     return Array<int> (rates, numElementsInArray (rates));

  950. }

  951. 

  952. Array<int> WavAudioFormat::getPossibleBitDepths()

  953. {

  954.     const int depths[] = { 8, 16, 24, 32 };

  955. 

  956.     return Array<int> (depths, numElementsInArray (depths));

  957. }

  958. 

  959. bool WavAudioFormat::canDoStereo()  { return true; }

  960. bool WavAudioFormat::canDoMono()    { return true; }

  961. 

  962. AudioFormatReader* WavAudioFormat::createReaderFor (InputStream* sourceStream,

  963.                                                     const bool deleteStreamIfOpeningFails)

  964. {

  965.     ScopedPointer<WavAudioFormatReader> r (new WavAudioFormatReader (sourceStream));

  966. 

  967.     if (r->sampleRate > 0 && r->numChannels > 0 && r->bytesPerFrame > 0)

  968.         return r.release();

  969. 

  970.     if (! deleteStreamIfOpeningFails)

  971.         r->input = nullptr;

  972. 

  973.     return nullptr;

  974. }

  975. 

  976. }