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);
}
