void CtrlrMIDITransaction::constructResponseMask()
{
MemoryBlock responseMask;
MemoryBlock prefix = getFormulaAsMemoryBlock(getProperty(Ids::transRespFormulaPrefix));
MemoryBlock data((int)getProperty(Ids::transRespDataLen), true);
MemoryBlock suffix = getFormulaAsMemoryBlock(getProperty(Ids::transRespFormulaSuffix));
MemoryBlock name = getNameAsMemoryBlock();
if (data.getSize() < name.getSize())
{
TRANS("["+getName()+"] CtrlrMIDITransaction::constructResponseMask data block will not fit name");
}
if (prefix.getSize() > 0)
{
responseMask.append (prefix.getData(), prefix.getSize());
}
if (data.getSize() > 0)
{
responseMask.append (data.getData(), data.getSize());
}
if (suffix.getSize() > 0)
{
responseMask.append (suffix.getData(), suffix.getSize());
}
setResponseMask (responseMask);
}
void CtrlrMIDITransaction::constructConfirmation()
{
MemoryBlock request;
MemoryBlock prefix = getFormulaAsMemoryBlock(getProperty(Ids::transConfFormulaPrefix));
MemoryBlock data = getConfirmationDataAsMemoryBlock();
MemoryBlock suffix = getFormulaAsMemoryBlock(getProperty(Ids::transConfFormulaSuffix));
if (prefix.getSize() > 0)
{
request.append (prefix.getData(), prefix.getSize());
}
if (data.getSize() > 0)
{
request.append (data.getData(), data.getSize());
}
if (suffix.getSize() > 0)
{
request.append (suffix.getData(), suffix.getSize());
}
setRequest (request);
}
void CtrlrMIDITransaction::constructRequest()
{
MemoryBlock request;
MemoryBlock prefix = getFormulaAsMemoryBlock(getProperty(Ids::transReqFormulaPrefix));
MemoryBlock data = getRequestDataAsMemoryBlock();
MemoryBlock suffix = getFormulaAsMemoryBlock(getProperty(Ids::transReqFormulaSuffix));
MemoryBlock name = getNameAsMemoryBlock();
if (data.getSize() < name.getSize())
{
TRANS("["+getName()+"] CtrlrMIDITransaction::constructRequest data block will not fit name");
}
if (prefix.getSize() > 0)
{
request.append (prefix.getData(), prefix.getSize());
}
if (data.getSize() > 0)
{
request.append (data.getData(), data.getSize());
}
if (suffix.getSize() > 0)
{
request.append (suffix.getData(), suffix.getSize());
}
setRequest (request);
}
String InputStream::readNextLine()
{
MemoryBlock buffer (256);
char* data = static_cast<char*> (buffer.getData());
size_t i = 0;
while ((data[i] = readByte()) != 0)
{
if (data[i] == '\n')
break;
if (data[i] == '\r')
{
const int64 lastPos = getPosition();
if (readByte() != '\n')
setPosition (lastPos);
break;
}
if (++i >= buffer.getSize())
{
buffer.setSize (buffer.getSize() + 512);
data = static_cast<char*> (buffer.getData());
}
}
return String::fromUTF8 (data, (int) i);
}
void CtrlrLuaAudioConverter::convertInt16 (MemoryBlock &sourceData, AudioSampleBuffer &destination, const int numSamples, const int numChannels, const bool interleaved)
{
if (interleaved)
{
AudioData::ConverterInstance < AudioData::Pointer <AudioData::Int16,
AudioData::NativeEndian,
AudioData::Interleaved,
AudioData::Const>,
AudioData::Pointer <AudioData::Float32,
AudioData::NativeEndian,
AudioData::Interleaved,
AudioData::NonConst>
> converter;
for (int ch=0; ch<numChannels; ch++)
{
converter.convertSamples ((void *)destination.getReadPointer(ch), sourceData.getData(), numSamples);
}
}
else
{
AudioData::ConverterInstance < AudioData::Pointer <AudioData::Int16,
AudioData::NativeEndian,
AudioData::NonInterleaved,
AudioData::Const>,
AudioData::Pointer <AudioData::Float32,
AudioData::NativeEndian,
AudioData::Interleaved,
AudioData::NonConst>
> converter;
for (int ch=0; ch<numChannels; ch++)
{
converter.convertSamples ((void *)destination.getReadPointer(ch), ch, sourceData.getData(), ch, numSamples);
}
}
}
//==============================================================================
bool InterprocessConnection::sendMessage (const MemoryBlock& message)
{
uint32 messageHeader[2] = { ByteOrder::swapIfBigEndian (magicMessageHeader),
ByteOrder::swapIfBigEndian ((uint32) message.getSize()) };
MemoryBlock messageData (sizeof (messageHeader) + message.getSize());
messageData.copyFrom (messageHeader, 0, sizeof (messageHeader));
messageData.copyFrom (message.getData(), sizeof (messageHeader), message.getSize());
return writeData (messageData.getData(), (int) messageData.getSize()) == (int) messageData.getSize();
}
static String getValue (const String& regValuePath, const String& defaultValue, DWORD wow64Flags)
{
MemoryBlock buffer;
switch (getBinaryValue (regValuePath, buffer, wow64Flags))
{
case REG_SZ: return static_cast <const WCHAR*> (buffer.getData());
case REG_DWORD: return String ((int) *reinterpret_cast<const DWORD*> (buffer.getData()));
default: break;
}
return defaultValue;
}
const MidiMessage createFromHexData (const String &hexData)
{
MemoryBlock bl;
bl.loadFromHexString(hexData);
return (MidiMessage ((uint8*)bl.getData(), (int)bl.getSize()));
}
BEAST_API OutputStream& BEAST_CALLTYPE operator<< (OutputStream& stream, const MemoryBlock& data)
{
if (data.getSize() > 0)
stream.write (data.getData(), data.getSize());
return stream;
}
const Result CtrlrWindows::getDefaultResources(MemoryBlock& dataToWrite)
{
#ifdef DEBUG_INSTANCE
File temp("c:\\devel\\debug_small.bpanelz");
MemoryBlock data;
{
ScopedPointer <FileInputStream> fis (temp.createInputStream());
fis->readIntoMemoryBlock (data);
}
ValueTree t = ValueTree::readFromGZIPData(data.getData(), data.getSize());
if (t.isValid())
{
ValueTree r = t.getChildWithName (Ids::resourceExportList);
if (r.isValid())
{
MemoryOutputStream mos (dataToWrite, false);
{
GZIPCompressorOutputStream gzipOutputStream (&mos);
r.writeToStream(gzipOutputStream);
gzipOutputStream.flush();
}
return (Result::ok());
}
}
else
{
return (Result::fail("Windows Native: getDefaultResources got data but couldn't parse it as a compressed ValueTree"));
}
#endif
return (readResource (nullptr, MAKEINTRESOURCE(CTRLR_INTERNAL_RESOURCES_RESID), RT_RCDATA, dataToWrite));
}
OutputStream& JUCE_CALLTYPE operator<< (OutputStream& stream, const MemoryBlock& data)
{
if (data.getSize() > 0)
stream.write (data.getData(), (int) data.getSize());
return stream;
}
static std::uint32_t getBinaryValue (const String& regValuePath, MemoryBlock& result, DWORD wow64Flags)
{
const RegistryKeyWrapper key (regValuePath, false, wow64Flags);
if (key.key != 0)
{
for (unsigned long bufferSize = 1024; ; bufferSize *= 2)
{
result.setSize (bufferSize, false);
DWORD type = REG_NONE;
const LONG err = RegQueryValueEx (key.key, key.wideCharValueName, 0, &type,
(LPBYTE) result.getData(), &bufferSize);
if (err == ERROR_SUCCESS)
{
result.setSize (bufferSize, false);
return type;
}
if (err != ERROR_MORE_DATA)
break;
}
}
return REG_NONE;
}
static void save_fxbp(SoundPlugin *plugin, wchar_t *wfilename, bool is_fxb){
Data *data = (Data*)plugin->data;
AudioPluginInstance *instance = data->audio_instance;
MemoryBlock memoryBlock;
bool result = VSTPluginFormat::saveToFXBFile(instance, memoryBlock, is_fxb);
if (result==false){
GFX_Message(NULL, "Unable to create FXB/FXP data for this plugin");
return;
}
String filename(wfilename);
File file(filename);
Result result2 = file.create();
if (result2.failed()){
GFX_Message(NULL, "Unable to create file %s (%s)", STRING_get_chars(wfilename), result2.getErrorMessage().toRawUTF8());
return;
}
bool result3 = file.replaceWithData(memoryBlock.getData(), memoryBlock.getSize());
if (result3==false){
GFX_Message(NULL, "Unable to write data to file %s (disk full?)", STRING_get_chars(wfilename));
return;
}
printf("\n\n\n ***************** result: %d\n\n\n\n",result);
}
void HostFilterComponent::handleSaveCommand(bool saveToExistingFileAndDontPrompt)
{
File tmp = currentSessionFile;
bool userConfirmed = true;
if (!saveToExistingFileAndDontPrompt || !tmp.exists())
{
FileChooser myChooser (T("Save Session..."),
currentSessionFile.exists() ? tmp : Config::getInstance ()->lastSessionDirectory,
JOST_SESSION_WILDCARD,
JOST_USE_NATIVE_FILE_CHOOSER);
if (myChooser.browseForFileToSave (true))
tmp = myChooser.getResult().withFileExtension (JOST_SESSION_EXTENSION);
else
userConfirmed = false;
}
if (userConfirmed && (tmp != File::nonexistent))
{
MemoryBlock fileData;
getFilter ()->getStateInformation (fileData);
if (tmp.replaceWithData (fileData.getData (), fileData.getSize()))
{
Config::getInstance()->addRecentSession (tmp);
setCurrentSessionFile(tmp);
Config::getInstance()->lastSessionFile = tmp;
}
}
}
void OnlineUnlockStatus::load()
{
MemoryBlock mb;
mb.fromBase64Encoding (getState());
if (mb.getSize() > 0)
status = ValueTree::readFromGZIPData (mb.getData(), mb.getSize());
else
status = ValueTree (stateTagName);
StringArray localMachineNums (getLocalMachineIDs());
if (machineNumberAllowed (StringArray ("1234"), localMachineNums))
status.removeProperty (unlockedProp, nullptr);
KeyFileUtils::KeyFileData data;
data = KeyFileUtils::getDataFromKeyFile (KeyFileUtils::getXmlFromKeyFile (status[keyfileDataProp], getPublicKey()));
if (data.keyFileExpires)
{
if (! doesProductIDMatch (data.appID))
status.removeProperty (expiryTimeProp, nullptr);
if (! machineNumberAllowed (data.machineNumbers, localMachineNums))
status.removeProperty (expiryTimeProp, nullptr);
}
else
{
if (! doesProductIDMatch (data.appID))
status.removeProperty (unlockedProp, nullptr);
if (! machineNumberAllowed (data.machineNumbers, localMachineNums))
status.removeProperty (unlockedProp, nullptr);
}
}
String InputStream::readString()
{
MemoryBlock buffer (256);
char* data = static_cast<char*> (buffer.getData());
size_t i = 0;
while ((data[i] = readByte()) != 0)
{
if (++i >= buffer.getSize())
{
buffer.setSize (buffer.getSize() + 512);
data = static_cast<char*> (buffer.getData());
}
}
return String::fromUTF8 (data, (int) i);
}
void openHTTPConnection (URL_COMPONENTS& uc, URL::OpenStreamProgressCallback* progressCallback,
void* progressCallbackContext)
{
const TCHAR* mimeTypes[] = { _T("*/*"), 0 };
DWORD flags = INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_NO_COOKIES;
if (address.startsWithIgnoreCase ("https:"))
flags |= INTERNET_FLAG_SECURE; // (this flag only seems necessary if the OS is running IE6 -
// IE7 seems to automatically work out when it's https)
request = HttpOpenRequest (connection, isPost ? _T("POST") : _T("GET"),
uc.lpszUrlPath, 0, 0, mimeTypes, flags, 0);
if (request != 0)
{
INTERNET_BUFFERS buffers = { 0 };
buffers.dwStructSize = sizeof (INTERNET_BUFFERS);
buffers.lpcszHeader = headers.toWideCharPointer();
buffers.dwHeadersLength = (DWORD) headers.length();
buffers.dwBufferTotal = (DWORD) postData.getSize();
if (HttpSendRequestEx (request, &buffers, 0, HSR_INITIATE, 0))
{
int bytesSent = 0;
for (;;)
{
const int bytesToDo = jmin (1024, (int) postData.getSize() - bytesSent);
DWORD bytesDone = 0;
if (bytesToDo > 0
&& ! InternetWriteFile (request,
static_cast <const char*> (postData.getData()) + bytesSent,
(DWORD) bytesToDo, &bytesDone))
{
break;
}
if (bytesToDo == 0 || (int) bytesDone < bytesToDo)
{
if (HttpEndRequest (request, 0, 0, 0))
return;
break;
}
bytesSent += bytesDone;
if (progressCallback != nullptr
&& ! progressCallback (progressCallbackContext, bytesSent, (int) postData.getSize()))
break;
}
}
}
close();
}
void writeDataAsCppLiteral (const MemoryBlock& mb, OutputStream& out)
{
const int maxCharsOnLine = 250;
const unsigned char* data = (const unsigned char*) mb.getData();
int charsOnLine = 0;
bool canUseStringLiteral = mb.getSize() < 32768; // MS compilers can't handle big string literals..
if (canUseStringLiteral)
{
unsigned int numEscaped = 0;
for (size_t i = 0; i < mb.getSize(); ++i)
{
const unsigned int num = (unsigned int) data[i];
if (! ((num >= 32 && num < 127) || num == '\t' || num == '\r' || num == '\n'))
{
if (++numEscaped > mb.getSize() / 4)
{
canUseStringLiteral = false;
break;
}
}
}
}
if (! canUseStringLiteral)
{
out << "{ ";
for (size_t i = 0; i < mb.getSize(); ++i)
{
const int num = (int) (unsigned int) data[i];
out << num << ',';
charsOnLine += 2;
if (num >= 10)
++charsOnLine;
if (num >= 100)
++charsOnLine;
if (charsOnLine >= maxCharsOnLine)
{
charsOnLine = 0;
out << newLine;
}
}
out << "0,0 };";
}
else
{
out << "\"";
writeEscapeChars (out, (const char*) data, (int) mb.getSize(), maxCharsOnLine, true, false);
out << "\";";
}
}
void work (const URIs& uris, const lvtk::Atom& atom) override
{
const File file (String::fromUTF8 (path.c_str()));
if (ScopedXml xml = XmlDocument::parse (file))
{
if (ScopedPointer<SamplerSynth> ss = SamplerSynth::create ())
{
if (ss->loadValueTreeXml (*xml))
{
#define compressd_json 1
#if compressd_json
var json;
const bool haveJson = ss->getNestedVariant (json);
#endif
uint8_t buf [2048];
getForge()->set_buffer (buf, 2048);
ObjectRef synth (*getForge(), uris.ksp1_SamplerSynth, ss.release());
respond (synth);
if (haveJson)
{
MemoryBlock block (0, false);
MemoryOutputStream stream (block, false);
GZIPCompressorOutputStream compressed (&stream, 9);
JSON::writeToStream (compressed, json, true);
compressed.flush();
if (block.getSize() > 0)
{
Forge& f = *getForge();
int bufSize = nextPowerOfTwo ((int) block.getSize());
bufSize = nextPowerOfTwo (bufSize);
MemoryBlock buffer ((size_t) bufSize, false);
f.set_buffer ((uint8*) buffer.getData(), buffer.getSize());
lvtk::Atom gzipped (f.write_atom (block.getSize(), 100100));
f.write_raw (block.getData(), block.getSize());
DBG ("SIZE: " << (int)block.getSize());
respond (gzipped);
}
}
}
}
}
}
void LashManager::saveState (const File& fileToSave)
{
MemoryBlock fileData;
filter->getStateInformation (fileData);
if (fileToSave.replaceWithData (fileData.getData (), fileData.getSize()))
{
}
}
void ProgramListBox::itemDropped(const SourceDetails& dragSourceDetails) {
dragCandidate = programPosition(dragSourceDetails.localPosition.x, dragSourceDetails.localPosition.y);
MemoryBlock* block = dragSourceDetails.description.getBinaryData();
if ( listener != nullptr )
listener->programDragged(this, dragCandidate, (char *)block->getData());
dragCandidate = -1;
repaint();
}
//==============================================================================
void getStateInformation (MemoryBlock& destData)
{
destData.setSize (sizeof (float) * getNumParameters());
destData.fillWith (0);
float* const p = (float*) ((char*) destData.getData());
for (int i = 0; i < getNumParameters(); ++i)
p[i] = getParameter(i);
}
MemoryInputStream::MemoryInputStream (const MemoryBlock& sourceData,
const bool keepInternalCopy)
: data (sourceData.getData()),
dataSize (sourceData.getSize()),
position (0)
{
if (keepInternalCopy)
createInternalCopy();
}
//==============================================================================
void LashManager::loadState (const File& fileToLoad)
{
MemoryBlock fileData;
if (fileToLoad.existsAsFile()
&& fileToLoad.loadFileAsData (fileData))
{
filter->setStateInformation (fileData.getData (), fileData.getSize());
}
}
//==============================================================================
static String readResponse (const int socketHandle, const uint32 timeOutTime)
{
int bytesRead = 0, numConsecutiveLFs = 0;
MemoryBlock buffer (1024, true);
while (numConsecutiveLFs < 2 && bytesRead < 32768
&& Time::getMillisecondCounter() <= timeOutTime)
{
fd_set readbits;
FD_ZERO (&readbits);
FD_SET (socketHandle, &readbits);
struct timeval tv;
tv.tv_sec = jmax (1, (int) (timeOutTime - Time::getMillisecondCounter()) / 1000);
tv.tv_usec = 0;
if (select (socketHandle + 1, &readbits, 0, 0, &tv) <= 0)
return String::empty; // (timeout)
buffer.ensureSize (bytesRead + 8, true);
char* const dest = (char*) buffer.getData() + bytesRead;
if (recv (socketHandle, dest, 1, 0) == -1)
return String::empty;
const char lastByte = *dest;
++bytesRead;
if (lastByte == '\n')
++numConsecutiveLFs;
else if (lastByte != '\r')
numConsecutiveLFs = 0;
}
const String header (CharPointer_UTF8 ((const char*) buffer.getData()));
if (header.startsWithIgnoreCase ("HTTP/"))
return header.trimEnd();
return String::empty;
}
//==============================================================================
bool InterprocessConnection::sendMessage (const MemoryBlock& message)
{
uint32 messageHeader[2];
messageHeader [0] = ByteOrder::swapIfBigEndian (magicMessageHeader);
messageHeader [1] = ByteOrder::swapIfBigEndian ((uint32) message.getSize());
MemoryBlock messageData (sizeof (messageHeader) + message.getSize());
messageData.copyFrom (messageHeader, 0, sizeof (messageHeader));
messageData.copyFrom (message.getData(), sizeof (messageHeader), message.getSize());
int bytesWritten = 0;
const ScopedLock sl (pipeAndSocketLock);
if (socket != nullptr)
bytesWritten = socket->write (messageData.getData(), (int) messageData.getSize());
else if (pipe != nullptr)
bytesWritten = pipe->write (messageData.getData(), (int) messageData.getSize(), pipeReceiveMessageTimeout);
return bytesWritten == (int) messageData.getSize();
}
//==============================================================================
bool InterprocessConnection::readNextMessageInt()
{
uint32 messageHeader[2];
const int bytes = socket != nullptr ? socket->read (messageHeader, sizeof (messageHeader), true)
: pipe ->read (messageHeader, sizeof (messageHeader), -1);
if (bytes == sizeof (messageHeader)
&& ByteOrder::swapIfBigEndian (messageHeader[0]) == magicMessageHeader)
{
int bytesInMessage = (int) ByteOrder::swapIfBigEndian (messageHeader[1]);
if (bytesInMessage > 0)
{
MemoryBlock messageData ((size_t) bytesInMessage, true);
int bytesRead = 0;
while (bytesInMessage > 0)
{
if (threadShouldExit())
return false;
const int numThisTime = jmin (bytesInMessage, 65536);
void* const data = addBytesToPointer (messageData.getData(), bytesRead);
const int bytesIn = socket != nullptr ? socket->read (data, numThisTime, true)
: pipe ->read (data, numThisTime, -1);
if (bytesIn <= 0)
break;
bytesRead += bytesIn;
bytesInMessage -= bytesIn;
}
if (bytesRead >= 0)
deliverDataInt (messageData);
}
}
else if (bytes < 0)
{
if (socket != nullptr)
{
const ScopedLock sl (pipeAndSocketLock);
socket = nullptr;
}
connectionLostInt();
return false;
}
return true;
}
const String LumaPlug::LumaDocument::loadDocument (const File& file)
{
FileInputStream* stream = file.createInputStream();
juce::int64 size = stream->getTotalLength();
if (size <= 0)
{
return String("Input file size is zero!");
}
MemoryBlock* buffer = new MemoryBlock(size+1, true);
int bytesRead = stream->read(buffer->getData(), size);
if (bytesRead != size)
{
return String("Bytes read from file differs from file size!");
}
String text = String(static_cast<char*>(buffer->getData()));
plug->newTextLoadedFromFile(text);
delete buffer;
return String::empty;
}
void WrappedJucePlugin::loadPresetFromXml(XmlElement* element)
{
if (instance)
{
XmlElement* chunk = element->getChildByName (T("juceVSTPluginData"));
if (chunk)
{
MemoryBlock mb;
mb.fromBase64Encoding (chunk->getAllSubText ());
instance->setStateInformation (mb.getData(), mb.getSize ());
}
}
}
var var::readFromStream (InputStream& input)
{
const int numBytes = input.readCompressedInt();
if (numBytes > 0)
{
switch (input.readByte())
{
case varMarker_Int: return var (input.readInt());
case varMarker_Int64: return var (input.readInt64());
case varMarker_BoolTrue: return var (true);
case varMarker_BoolFalse: return var (false);
case varMarker_Double: return var (input.readDouble());
case varMarker_String:
{
MemoryOutputStream mo;
mo.writeFromInputStream (input, numBytes - 1);
return var (mo.toUTF8());
}
case varMarker_Binary:
{
MemoryBlock mb (numBytes - 1);
if (numBytes > 1)
{
const int numRead = input.read (mb.getData(), numBytes - 1);
mb.setSize (numRead);
}
return var (mb);
}
case varMarker_Array:
{
var v;
Array<var>* const destArray = v.convertToArray();
for (int i = input.readCompressedInt(); --i >= 0;)
destArray->add (readFromStream (input));
return v;
}
default:
input.skipNextBytes (numBytes - 1); break;
}
}
return var::null;
}