static void findTimeSigEvents (MidiFile& midiFile, StringPairArray& midiMetadata)
{
MidiMessageSequence timeSigEvents;
midiFile.findAllTimeSigEvents (timeSigEvents);
const int numTimeSigEvents = timeSigEvents.getNumEvents();
MemoryOutputStream timeSigSequence;
for (int i = 0; i < numTimeSigEvents; ++i)
{
int numerator, denominator;
timeSigEvents.getEventPointer(i)->message.getTimeSignatureInfo (numerator, denominator);
String timeSigString;
timeSigString << numerator << '/' << denominator;
if (i == 0)
midiMetadata.set (CoreAudioFormat::timeSig, timeSigString);
if (numTimeSigEvents > 1)
timeSigSequence << timeSigString << ',' << timeSigEvents.getEventTime (i) << ';';
}
if (timeSigSequence.getDataSize() > 0)
midiMetadata.set ("time signature sequence", timeSigSequence.toString());
}
static void findTempoEvents (MidiFile& midiFile, StringPairArray& midiMetadata)
{
MidiMessageSequence tempoEvents;
midiFile.findAllTempoEvents (tempoEvents);
const int numTempoEvents = tempoEvents.getNumEvents();
MemoryOutputStream tempoSequence;
for (int i = 0; i < numTempoEvents; ++i)
{
const double tempo = getTempoFromTempoMetaEvent (tempoEvents.getEventPointer (i));
if (tempo > 0.0)
{
if (i == 0)
midiMetadata.set (CoreAudioFormat::tempo, String (tempo));
if (numTempoEvents > 1)
tempoSequence << String (tempo) << ',' << tempoEvents.getEventTime (i) << ';';
}
}
if (tempoSequence.getDataSize() > 0)
midiMetadata.set ("tempo sequence", tempoSequence.toString());
}
String PerformanceCounter::Statistics::toString() const
{
MemoryOutputStream s;
s << "Performance count for \"" << name << "\" over " << numRuns << " run(s)" << newLine
<< "Average = " << timeToString (averageSeconds)
<< ", minimum = " << timeToString (minimumSeconds)
<< ", maximum = " << timeToString (maximumSeconds)
<< ", total = " << timeToString (totalSeconds);
return s.toString();
}
XmlElement* XmlDocument::getDocumentElement (const bool onlyReadOuterDocumentElement)
{
if (originalText.isEmpty() && inputSource != nullptr)
{
ScopedPointer<InputStream> in (inputSource->createInputStream());
if (in != nullptr)
{
MemoryOutputStream data;
data.writeFromInputStream (*in, onlyReadOuterDocumentElement ? 8192 : -1);
#if JUCE_STRING_UTF_TYPE == 8
if (data.getDataSize() > 2)
{
data.writeByte (0);
const char* text = static_cast<const char*> (data.getData());
if (CharPointer_UTF16::isByteOrderMarkBigEndian (text)
|| CharPointer_UTF16::isByteOrderMarkLittleEndian (text))
{
originalText = data.toString();
}
else
{
if (CharPointer_UTF8::isByteOrderMark (text))
text += 3;
// parse the input buffer directly to avoid copying it all to a string..
return parseDocumentElement (String::CharPointerType (text), onlyReadOuterDocumentElement);
}
}
#else
originalText = data.toString();
#endif
}
}
return parseDocumentElement (originalText.getCharPointer(), onlyReadOuterDocumentElement);
}
XmlElement* XmlDocument::getDocumentElement (const bool onlyReadOuterDocumentElement)
{
String textToParse (originalText);
if (textToParse.isEmpty() && inputSource != nullptr)
{
ScopedPointer <InputStream> in (inputSource->createInputStream());
if (in != nullptr)
{
MemoryOutputStream data;
data.writeFromInputStream (*in, onlyReadOuterDocumentElement ? 8192 : -1);
textToParse = data.toString();
if (! onlyReadOuterDocumentElement)
originalText = textToParse;
}
}
input = textToParse.getCharPointer();
lastError = String::empty;
errorOccurred = false;
outOfData = false;
needToLoadDTD = true;
if (textToParse.isEmpty())
{
lastError = "not enough input";
}
else
{
skipHeader();
if (input.getAddress() != nullptr)
{
ScopedPointer <XmlElement> result (readNextElement (! onlyReadOuterDocumentElement));
if (! errorOccurred)
return result.release();
}
else
{
lastError = "incorrect xml header";
}
}
return nullptr;
}
String ChildProcess::readAllProcessOutput()
{
MemoryOutputStream result;
for (;;)
{
char buffer [512];
const int num = readProcessOutput (buffer, sizeof (buffer));
if (num <= 0)
break;
result.write (buffer, (size_t) num);
}
return result.toString();
}
String CodeDocument::getTextBetween (const Position& start, const Position& end) const
{
if (end.getPosition() <= start.getPosition())
return String::empty;
const int startLine = start.getLineNumber();
const int endLine = end.getLineNumber();
if (startLine == endLine)
{
if (CodeDocumentLine* const line = lines [startLine])
return line->line.substring (start.getIndexInLine(), end.getIndexInLine());
return String::empty;
}
MemoryOutputStream mo;
mo.preallocate ((size_t) (end.getPosition() - start.getPosition() + 4));
const int maxLine = jmin (lines.size() - 1, endLine);
for (int i = jmax (0, startLine); i <= maxLine; ++i)
{
const CodeDocumentLine& line = *lines.getUnchecked(i);
int len = line.lineLength;
if (i == startLine)
{
const int index = start.getIndexInLine();
mo << line.line.substring (index, len);
}
else if (i == endLine)
{
len = end.getIndexInLine();
mo << line.line.substring (0, len);
}
else
{
mo << line.line;
}
}
return mo.toString();
}
// Updates the text in our position label.
void JuceDemoPluginAudioProcessorEditor::updateTimecodeDisplay (AudioPlayHead::CurrentPositionInfo pos)
{
MemoryOutputStream displayText;
displayText << "[" << SystemStats::getJUCEVersion() << "] "
<< String (pos.bpm, 2) << " bpm, "
<< pos.timeSigNumerator << '/' << pos.timeSigDenominator
<< " - " << timeToTimecodeString (pos.timeInSeconds)
<< " - " << quarterNotePositionToBarsBeatsString (pos.ppqPosition,
pos.timeSigNumerator,
pos.timeSigDenominator);
if (pos.isRecording)
displayText << " (recording)";
else if (pos.isPlaying)
displayText << " (playing)";
timecodeDisplayLabel.setText (displayText.toString(), dontSendNotification);
}
//==============================================================================
ProjucerAnalyticsDestination::ProjucerAnalyticsDestination()
: ThreadedAnalyticsDestination ("ProjucerAnalyticsThread")
{
{
MemoryOutputStream mo;
if (Base64::convertFromBase64 (mo, BinaryData::nothingtoseehere_txt))
apiKey = mo.toString();
}
auto dataDir = File::getSpecialLocation (File::userApplicationDataDirectory)
#if JUCE_MAC
.getChildFile ("Application Support")
#endif
.getChildFile ("Projucer")
.getChildFile ("Analytics");
if (! dataDir.exists())
dataDir.createDirectory();
savedEventsFile = dataDir.getChildFile ("analytics_events.xml");
startAnalyticsThread (initialPeriodMs);
}
String InputStream::readEntireStreamAsString()
{
MemoryOutputStream mo;
mo << *this;
return mo.toString();
}
//==============================================================================
void BinaryResources::fillInGeneratedCode (GeneratedCode& code) const
{
if (resources.size() > 0)
{
code.publicMemberDeclarations << "// Binary resources:\n";
MemoryOutputStream defs;
defs << "//==============================================================================\n";
defs << "// Binary resources - be careful not to edit any of these sections!\n\n";
for (int i = 0; i < resources.size(); ++i)
{
code.publicMemberDeclarations
<< "static const char* "
<< resources[i]->name
<< ";\nstatic const int "
<< resources[i]->name
<< "Size;\n";
const String name (resources[i]->name);
const MemoryBlock& mb = resources[i]->data;
defs << "// JUCER_RESOURCE: " << name << ", " << (int) mb.getSize()
<< ", \""
<< File (resources[i]->originalFilename)
.getRelativePathFrom (code.document->getCppFile())
.replaceCharacter ('\\', '/')
<< "\"\n";
String line1;
line1 << "static const unsigned char resource_"
<< code.className << "_" << name << "[] = { ";
defs << line1;
int charsOnLine = line1.length();
for (size_t j = 0; j < mb.getSize(); ++j)
{
const int num = (int) (unsigned char) mb[j];
defs << num << ',';
charsOnLine += 2;
if (num >= 10) ++charsOnLine;
if (num >= 100) ++charsOnLine;
if (charsOnLine >= 200)
{
charsOnLine = 0;
defs << '\n';
}
}
defs
<< "0,0};\n\n"
"const char* " << code.className << "::" << name
<< " = (const char*) resource_" << code.className << "_" << name
<< ";\nconst int "
<< code.className << "::" << name << "Size = "
<< (int) mb.getSize()
<< ";\n\n";
}
code.staticMemberDefinitions << defs.toString();
}
}
int read (void* buffer, int bytesToRead) override
{
if (finished || isError())
return 0;
if (isChunked && ! readingChunk)
{
if (position >= chunkEnd)
{
const ScopedValueSetter<bool> setter (readingChunk, true, false);
MemoryOutputStream chunkLengthBuffer;
char c = 0;
if (chunkEnd > 0)
{
if (read (&c, 1) != 1 || c != '\r'
|| read (&c, 1) != 1 || c != '\n')
{
finished = true;
return 0;
}
}
while (chunkLengthBuffer.getDataSize() < 512 && ! (finished || isError()))
{
if (read (&c, 1) != 1)
{
finished = true;
return 0;
}
if (c == '\r')
continue;
if (c == '\n')
break;
chunkLengthBuffer.writeByte (c);
}
const int64 chunkSize = chunkLengthBuffer.toString().trimStart().getHexValue64();
if (chunkSize == 0)
{
finished = true;
return 0;
}
chunkEnd += chunkSize;
}
if (bytesToRead > chunkEnd - position)
bytesToRead = static_cast<int> (chunkEnd - position);
}
fd_set readbits;
FD_ZERO (&readbits);
FD_SET (socketHandle, &readbits);
struct timeval tv;
tv.tv_sec = jmax (1, timeOutMs / 1000);
tv.tv_usec = 0;
if (select (socketHandle + 1, &readbits, 0, 0, &tv) <= 0)
return 0; // (timeout)
const int bytesRead = jmax (0, (int) recv (socketHandle, buffer, (size_t) bytesToRead, MSG_WAITALL));
if (bytesRead == 0)
finished = true;
if (! readingChunk)
position += bytesRead;
return bytesRead;
}
//==============================================================================
void ProjectSaver::writePluginCharacteristicsFile()
{
StringPairArray flags;
flags.set ("JucePlugin_Build_VST", boolToString (project.shouldBuildVST()));
flags.set ("JucePlugin_Build_VST3", boolToString (project.shouldBuildVST3()));
flags.set ("JucePlugin_Build_AU", boolToString (project.shouldBuildAU()));
flags.set ("JucePlugin_Build_AUv3", boolToString (project.shouldBuildAUv3()));
flags.set ("JucePlugin_Build_RTAS", boolToString (project.shouldBuildRTAS()));
flags.set ("JucePlugin_Build_AAX", boolToString (project.shouldBuildAAX()));
flags.set ("JucePlugin_Build_Standalone", boolToString (project.shouldBuildStandalonePlugin()));
flags.set ("JucePlugin_Build_Unity", boolToString (project.shouldBuildUnityPlugin()));
flags.set ("JucePlugin_Enable_IAA", boolToString (project.shouldEnableIAA()));
flags.set ("JucePlugin_Name", toStringLiteral (project.getPluginNameString()));
flags.set ("JucePlugin_Desc", toStringLiteral (project.getPluginDescriptionString()));
flags.set ("JucePlugin_Manufacturer", toStringLiteral (project.getPluginManufacturerString()));
flags.set ("JucePlugin_ManufacturerWebsite", toStringLiteral (project.getCompanyWebsiteString()));
flags.set ("JucePlugin_ManufacturerEmail", toStringLiteral (project.getCompanyEmailString()));
flags.set ("JucePlugin_ManufacturerCode", toCharLiteral (project.getPluginManufacturerCodeString()));
flags.set ("JucePlugin_PluginCode", toCharLiteral (project.getPluginCodeString()));
flags.set ("JucePlugin_IsSynth", boolToString (project.isPluginSynth()));
flags.set ("JucePlugin_WantsMidiInput", boolToString (project.pluginWantsMidiInput()));
flags.set ("JucePlugin_ProducesMidiOutput", boolToString (project.pluginProducesMidiOutput()));
flags.set ("JucePlugin_IsMidiEffect", boolToString (project.isPluginMidiEffect()));
flags.set ("JucePlugin_EditorRequiresKeyboardFocus", boolToString (project.pluginEditorNeedsKeyFocus()));
flags.set ("JucePlugin_Version", project.getVersionString());
flags.set ("JucePlugin_VersionCode", project.getVersionAsHex());
flags.set ("JucePlugin_VersionString", toStringLiteral (project.getVersionString()));
flags.set ("JucePlugin_VSTUniqueID", "JucePlugin_PluginCode");
flags.set ("JucePlugin_VSTCategory", project.getVSTCategoryString());
flags.set ("JucePlugin_Vst3Category", toStringLiteral (project.getVST3CategoryString()));
flags.set ("JucePlugin_AUMainType", project.getAUMainTypeString());
flags.set ("JucePlugin_AUSubType", "JucePlugin_PluginCode");
flags.set ("JucePlugin_AUExportPrefix", project.getPluginAUExportPrefixString());
flags.set ("JucePlugin_AUExportPrefixQuoted", toStringLiteral (project.getPluginAUExportPrefixString()));
flags.set ("JucePlugin_AUManufacturerCode", "JucePlugin_ManufacturerCode");
flags.set ("JucePlugin_CFBundleIdentifier", project.getBundleIdentifierString());
flags.set ("JucePlugin_RTASCategory", String (project.getRTASCategory()));
flags.set ("JucePlugin_RTASManufacturerCode", "JucePlugin_ManufacturerCode");
flags.set ("JucePlugin_RTASProductId", "JucePlugin_PluginCode");
flags.set ("JucePlugin_RTASDisableBypass", boolToString (project.isPluginRTASBypassDisabled()));
flags.set ("JucePlugin_RTASDisableMultiMono", boolToString (project.isPluginRTASMultiMonoDisabled()));
flags.set ("JucePlugin_AAXIdentifier", project.getAAXIdentifierString());
flags.set ("JucePlugin_AAXManufacturerCode", "JucePlugin_ManufacturerCode");
flags.set ("JucePlugin_AAXProductId", "JucePlugin_PluginCode");
flags.set ("JucePlugin_AAXCategory", String (project.getAAXCategory()));
flags.set ("JucePlugin_AAXDisableBypass", boolToString (project.isPluginAAXBypassDisabled()));
flags.set ("JucePlugin_AAXDisableMultiMono", boolToString (project.isPluginAAXMultiMonoDisabled()));
flags.set ("JucePlugin_IAAType", toCharLiteral (project.getIAATypeCode()));
flags.set ("JucePlugin_IAASubType", "JucePlugin_PluginCode");
flags.set ("JucePlugin_IAAName", project.getIAAPluginName().quoted());
flags.set ("JucePlugin_VSTNumMidiInputs", project.getVSTNumMIDIInputsString());
flags.set ("JucePlugin_VSTNumMidiOutputs", project.getVSTNumMIDIOutputsString());
{
String plugInChannelConfig = project.getPluginChannelConfigsString();
if (plugInChannelConfig.isNotEmpty())
{
flags.set ("JucePlugin_MaxNumInputChannels", String (countMaxPluginChannels (plugInChannelConfig, true)));
flags.set ("JucePlugin_MaxNumOutputChannels", String (countMaxPluginChannels (plugInChannelConfig, false)));
flags.set ("JucePlugin_PreferredChannelConfigurations", plugInChannelConfig);
}
}
MemoryOutputStream mem;
mem.setNewLineString (projectLineFeed);
mem << "//==============================================================================" << newLine
<< "// Audio plugin settings.." << newLine
<< newLine;
for (int i = 0; i < flags.size(); ++i)
{
mem << "#ifndef " << flags.getAllKeys()[i] << newLine
<< " #define " << flags.getAllKeys()[i].paddedRight (' ', 32) << " "
<< flags.getAllValues()[i] << newLine
<< "#endif" << newLine;
}
setExtraAppConfigFileContent (mem.toString());
}