bool InputSoundFile::openFromMemory(const void* data, std::size_t sizeInBytes) { // If the file is already open, first close it close(); // Find a suitable reader for the file type m_reader = SoundFileFactory::createReaderFromMemory(data, sizeInBytes); if (!m_reader) return false; // Wrap the memory file into a stream MemoryInputStream* memory = new MemoryInputStream; m_stream = memory; m_streamOwned = true; // Open it memory->open(data, sizeInBytes); // Pass the stream to the reader SoundFileReader::Info info; if (!m_reader->open(*memory, info)) { close(); return false; } // Retrieve the attributes of the open sound file m_sampleCount = info.sampleCount; m_channelCount = info.channelCount; m_sampleRate = info.sampleRate; return true; }
static String parseNameRecord (MemoryInputStream& input, const NameRecord& nameRecord, const int64 directoryOffset, const int64 offsetOfStringStorage) { String result; const int64 oldPos = input.getPosition(); input.setPosition (directoryOffset + offsetOfStringStorage + ByteOrder::swapIfLittleEndian (nameRecord.offsetFromStorageArea)); const int stringLength = (int) ByteOrder::swapIfLittleEndian (nameRecord.stringLength); const int platformID = ByteOrder::swapIfLittleEndian (nameRecord.platformID); if (platformID == 0 || platformID == 3) { const int numChars = stringLength / 2 + 1; HeapBlock<uint16> buffer; buffer.calloc (numChars + 1); input.read (buffer, stringLength); for (int i = 0; i < numChars; ++i) buffer[i] = ByteOrder::swapIfLittleEndian (buffer[i]); static_jassert (sizeof (CharPointer_UTF16::CharType) == sizeof (uint16)); result = CharPointer_UTF16 ((CharPointer_UTF16::CharType*) buffer.getData()); } else { HeapBlock<char> buffer; buffer.calloc (stringLength + 1); input.read (buffer, stringLength); result = CharPointer_UTF8 (buffer.getData()); } input.setPosition (oldPos); return result; }
void setStateInformation (const void* data, int sizeInBytes) override { MemoryInputStream stream (data, static_cast<size_t> (sizeInBytes), false); threshold->setValueNotifyingHost (stream.readFloat()); alpha->setValueNotifyingHost (stream.readFloat()); }
void setStateInformation (const void* data, int sizeInBytes) override { MemoryInputStream stream (data, sizeInBytes, false); radius->setValueNotifyingHost (stream.readFloat()); phi->setValueNotifyingHost (stream.readFloat()); }
void setStateInformation (const void* data, int sizeInBytes) override { MemoryInputStream stream (data, static_cast<size_t> (sizeInBytes), false); isRecordingParam->setValueNotifyingHost (stream.readFloat()); roomSizeParam->setValueNotifyingHost (stream.readFloat()); }
void runTest() override { beginTest ("Basics"); Random r = getRandom(); int randomInt = r.nextInt(); int64 randomInt64 = r.nextInt64(); double randomDouble = r.nextDouble(); String randomString (createRandomWideCharString (r)); MemoryOutputStream mo; mo.writeInt (randomInt); mo.writeIntBigEndian (randomInt); mo.writeCompressedInt (randomInt); mo.writeString (randomString); mo.writeInt64 (randomInt64); mo.writeInt64BigEndian (randomInt64); mo.writeDouble (randomDouble); mo.writeDoubleBigEndian (randomDouble); MemoryInputStream mi (mo.getData(), mo.getDataSize(), false); expect (mi.readInt() == randomInt); expect (mi.readIntBigEndian() == randomInt); expect (mi.readCompressedInt() == randomInt); expectEquals (mi.readString(), randomString); expect (mi.readInt64() == randomInt64); expect (mi.readInt64BigEndian() == randomInt64); expect (mi.readDouble() == randomDouble); expect (mi.readDoubleBigEndian() == randomDouble); }
void CabbageIDELookAndFeel::drawAlertBox (Graphics& g, AlertWindow& alert, const Rectangle<int>& textArea, TextLayout& textLayout) { g.fillAll (CabbageSettings::getColourFromValueTree (colourTree, CabbageColourIds::alertWindowBackground, Colour (Colour::fromString("2ff52636a")))); int iconSpaceUsed = 160; if (alert.getAlertType() != AlertWindow::NoIcon) { Path icon; if (alert.getAlertType() == AlertWindow::WarningIcon) { Rectangle<float> rect (alert.getLocalBounds().removeFromLeft (iconSpaceUsed).toFloat()); const Image warningImage = ImageCache::getFromMemory (CabbageBinaryData::WarningIcon_png, CabbageBinaryData::WarningIcon_pngSize); //g.drawImage(warningImage, rect.reduced(20)); } if (alert.getAlertType() == AlertWindow::QuestionIcon) { Rectangle<float> rect (alert.getLocalBounds().removeFromLeft (iconSpaceUsed - 20).toFloat()); const Image warningImage = ImageCache::getFromMemory (CabbageBinaryData::WarningIcon_png, CabbageBinaryData::WarningIcon_pngSize); //g.drawImage(warningImage, rect.reduced(25)); } MemoryInputStream svgStream (CabbageBinaryData::processstop_svg, CabbageBinaryData::processstop_svgSize, false); ScopedPointer<XmlElement> svg (XmlDocument::parse (svgStream.readString())); if (svg == nullptr) jassert (false); ScopedPointer<Drawable> drawable; if (svg != nullptr) { drawable = Drawable::createFromSVG (*svg); Rectangle<float> rect (20, 20, 80, 80);//alert.getLocalBounds().removeFromLeft (iconSpaceUsed - 20).withHeight(130).toFloat()); drawable->setTransformToFit (rect, RectanglePlacement::stretchToFit); drawable->draw (g, 1.f, AffineTransform()); } } g.setColour (alert.findColour (AlertWindow::textColourId)); textLayout.draw (g, Rectangle<int> (textArea.getX() + iconSpaceUsed - 50, textArea.getY(), textArea.getWidth() - iconSpaceUsed - 40, textArea.getHeight()).toFloat()); g.setColour (alert.findColour (AlertWindow::outlineColourId)); g.drawRect (0, 0, alert.getWidth(), alert.getHeight()); }
static String getTypefaceNameFromFile (MemoryInputStream& input) { OffsetTable offsetTable = { 0 }; input.read (&offsetTable, sizeof (offsetTable)); for (int i = 0; i < (int) ByteOrder::swapIfLittleEndian (offsetTable.numTables); ++i) { TableDirectory tableDirectory; zerostruct (tableDirectory); input.read (&tableDirectory, sizeof (tableDirectory)); if (String (tableDirectory.tag, sizeof (tableDirectory.tag)).equalsIgnoreCase ("name")) return parseNameTable (input, ByteOrder::swapIfLittleEndian (tableDirectory.offset)); } return {}; }
void TommyCoin::Read( MemoryInputStream& inStream ) { if( inStream.GetRemainingBytes() >= 3 * sizeof( float ) + sizeof( XMVECTOR ) ) { XMVECTORF32 location = { 0 }; inStream.Read( location.f[ 0 ] ); inStream.Read( location.f[ 1 ] ); SetLocation( location ); float rotation; inStream.Read( rotation ); SetRotation( rotation ); XMVECTOR color; inStream.Read( color ); SetColor( color ); } }
static ValueTree readSubTreeLocation (MemoryInputStream& input, ValueTree v) { const int numLevels = input.readCompressedInt(); if (! isPositiveAndBelow (numLevels, 65536)) // sanity-check return {}; for (int i = numLevels; --i >= 0;) { const int index = input.readCompressedInt(); if (! isPositiveAndBelow (index, v.getNumChildren())) return {}; v = v.getChild (index); } return v; }
static String parseNameTable (MemoryInputStream& input, int64 directoryOffset) { input.setPosition (directoryOffset); NamingTable namingTable = { 0 }; input.read (&namingTable, sizeof (namingTable)); for (int i = 0; i < (int) ByteOrder::swapIfLittleEndian (namingTable.numberOfNameRecords); ++i) { NameRecord nameRecord = { 0 }; input.read (&nameRecord, sizeof (nameRecord)); if (ByteOrder::swapIfLittleEndian (nameRecord.nameID) == 4) { const String result (parseNameRecord (input, nameRecord, directoryOffset, ByteOrder::swapIfLittleEndian (namingTable.offsetStartOfStringStorage))); if (result.isNotEmpty()) return result; } } return String(); }
void MiditoOscAudioProcessor::setStateInformation (const void* data, int sizeInBytes) { // You should use this method to restore your parameters from this memory block, // whose contents will have been created by the getStateInformation() call. MemoryInputStream stream (data, static_cast<size_t> (sizeInBytes), false); polyphony->setValueNotifyingHost (stream.readInt()); glide->setValueNotifyingHost (stream.readFloat()); mono->setValueNotifyingHost (stream.readBool()); shift->setValueNotifyingHost (stream.readBool()); scale->setValueNotifyingHost (stream.readInt()); }
bool UploadManager::prepareFile(UserConnection& aSource, const string& aType, const string& aFile, int64_t aStartPos, int64_t aBytes, bool listRecursive) { if(aFile.empty() || aStartPos < 0 || aBytes < -1 || aBytes == 0) { aSource.fileNotAvail("Invalid request"); return false; } InputStream* is = 0; int64_t start = 0; int64_t bytesLeft = 0; int64_t size = 0; bool userlist = (aFile == Transfer::USER_LIST_NAME_BZ || aFile == Transfer::USER_LIST_NAME); bool free = userlist; bool leaves = false; bool partList = false; string sourceFile; try { if(aType == Transfer::TYPE_FILE) { sourceFile = ShareManager::getInstance()->toReal(aFile); if(aFile == Transfer::USER_LIST_NAME) { // Unpack before sending... string bz2 = File(sourceFile, File::READ, File::OPEN).read(); string xml; CryptoManager::getInstance()->decodeBZ2(reinterpret_cast<const uint8_t*>(bz2.data()), bz2.size(), xml); // Clear to save some memory... string().swap(bz2); is = new MemoryInputStream(xml); start = 0; bytesLeft = size = xml.size(); } else { File* f = new File(sourceFile, File::READ, File::OPEN); start = aStartPos; size = f->getSize(); bytesLeft = (aBytes == -1) ? size : aBytes; if(size < (start + bytesLeft)) { aSource.fileNotAvail(); delete f; return false; } free = free || (size <= (int64_t)(SETTING(FREE_SLOTS_SIZE) * 1024) ); f->setPos(start); is = f; if((start + bytesLeft) < size) { is = new LimitedInputStream<true>(is, aBytes); } } } else if(aType == Transfer::TYPE_TTHL) { sourceFile = ShareManager::getInstance()->toReal(aFile); MemoryInputStream* mis = ShareManager::getInstance()->getTree(aFile); if(!mis) { aSource.fileNotAvail(); return false; } start = 0; bytesLeft = size = mis->getSize(); is = mis; leaves = true; free = true; } else { aSource.fileNotAvail("Unknown file type"); return false; } } catch(const ShareException& e) { aSource.fileNotAvail(e.getError()); return false; } catch(const Exception& e) { LogManager::getInstance()->message(STRING(UNABLE_TO_SEND_FILE) + sourceFile + ": " + e.getError()); aSource.fileNotAvail(); return false; } Lock l(cs); bool extraSlot = false; if(!aSource.isSet(UserConnection::FLAG_HASSLOT)) { bool hasReserved = (reservedSlots.find(aSource.getUser()) != reservedSlots.end()); bool isFavorite = aSource.getUser()->getFavoriteGrantSlot(); if(!(hasReserved || isFavorite || getFreeSlots() > 0 || getAutoSlot())) { bool supportsFree = aSource.isSet(UserConnection::FLAG_SUPPORTS_MINISLOTS); bool allowedFree = aSource.isSet(UserConnection::FLAG_HASEXTRASLOT) || aSource.isSet(UserConnection::FLAG_OP) || getFreeExtraSlots() > 0; if(free && supportsFree && allowedFree) { extraSlot = true; } else { delete is; aSource.maxedOut(); // Check for tth root identifier string tFile = aFile; if (tFile.compare(0, 4, "TTH/") == 0) tFile = ShareManager::getInstance()->toVirtual(TTHValue(aFile.substr(4))); addFailedUpload(aSource, tFile + " (" + Util::toString((aStartPos*1000/(size+10))/10.0)+"% of " + Util::formatBytes(size) + " done)"); aSource.disconnect(); return false; } } else { clearUserFiles(aSource.getUser()); // this user is using a full slot, nix them. } setLastGrant(GET_TICK()); } Upload* u = new Upload(aSource); u->setStream(is); if(aBytes == -1) u->setSize(size); else u->setSize(start + bytesLeft); u->setStartPos(start); u->setSourceFile(sourceFile); if(userlist) u->setFlag(Upload::FLAG_USER_LIST); if(leaves) u->setFlag(Upload::FLAG_TTH_LEAVES); if(partList) u->setFlag(Upload::FLAG_PARTIAL_LIST); uploads.push_back(u); if(!aSource.isSet(UserConnection::FLAG_HASSLOT)) { if(extraSlot) { if(!aSource.isSet(UserConnection::FLAG_HASEXTRASLOT)) { aSource.setFlag(UserConnection::FLAG_HASEXTRASLOT); extra++; } } else { if(aSource.isSet(UserConnection::FLAG_HASEXTRASLOT)) { aSource.unsetFlag(UserConnection::FLAG_HASEXTRASLOT); extra--; } aSource.setFlag(UserConnection::FLAG_HASSLOT); running++; } reservedSlots.erase(aSource.getUser()); } return true; }
bool ValueTreeSynchroniser::applyChange (ValueTree& root, const void* data, size_t dataSize, UndoManager* undoManager) { MemoryInputStream input (data, dataSize, false); const ValueTreeSynchroniserHelpers::ChangeType type = (ValueTreeSynchroniserHelpers::ChangeType) input.readByte(); if (type == ValueTreeSynchroniserHelpers::fullSync) { root = ValueTree::readFromStream (input); return true; } ValueTree v (ValueTreeSynchroniserHelpers::readSubTreeLocation (input, root)); if (! v.isValid()) return false; switch (type) { case ValueTreeSynchroniserHelpers::propertyChanged: { Identifier property (input.readString()); v.setProperty (property, var::readFromStream (input), undoManager); return true; } case ValueTreeSynchroniserHelpers::propertyRemoved: { Identifier property (input.readString()); v.removeProperty (property, undoManager); return true; } case ValueTreeSynchroniserHelpers::childAdded: { const int index = input.readCompressedInt(); v.addChild (ValueTree::readFromStream (input), index, undoManager); return true; } case ValueTreeSynchroniserHelpers::childRemoved: { const int index = input.readCompressedInt(); if (isPositiveAndBelow (index, v.getNumChildren())) { v.removeChild (index, undoManager); return true; } jassertfalse; // Either received some corrupt data, or the trees have drifted out of sync break; } case ValueTreeSynchroniserHelpers::childMoved: { const int oldIndex = input.readCompressedInt(); const int newIndex = input.readCompressedInt(); if (isPositiveAndBelow (oldIndex, v.getNumChildren()) && isPositiveAndBelow (newIndex, v.getNumChildren())) { v.moveChild (oldIndex, newIndex, undoManager); return true; } jassertfalse; // Either received some corrupt data, or the trees have drifted out of sync break; } default: jassertfalse; // Seem to have received some corrupt data? break; } return false; }
virtual InputStream* createInputStreamFor (const String& ) { return new MemoryInputStream(stream_->getData(), stream_->getDataSize(), false); }