static
void getLenOfPspSeqs(FILE *fptr, Psprior *psp) {
char c;
char prevC = 0;
int seqInd = -1;
boolean inHeader = FALSE;
boolean inSeq = FALSE;
while ((c = fgetc(fptr)) != EOF) {
if( c == '>' ) {
inHeader = TRUE;
inSeq = FALSE;
if(prevC != '>') {
seqInd++; //do not increment if >> in header
}
if(seqInd >= psp->numseqs) {
print_error("ERROR in getLenOfSeqs: number of seqs exceed max.");
}
psp->seqlen[seqInd] = 0;
}
else if ( inHeader && c == '\n') {
inHeader = FALSE;
inSeq = TRUE;
}
else if (inSeq) {
if(isFloatingPoint(prevC) && isSpaceChar(c)) {
psp->seqlen[seqInd]++;
//fprintf(stderr, "case1\n");
}
else if(isSpaceChar(prevC) && isSpaceChar(c)) {
//do nothing
//fprintf(stderr, "case2\n");
}
else if(isSpaceChar(prevC) && isFloatingPoint(c)) {
//do nothing
//fprintf(stderr, "case3\n");
}
else if(isFloatingPoint(prevC) && isFloatingPoint(c)) {
//do nothing
//fprintf(stderr, "case4\n");
}
else {
fprintf(stderr, "character: %d %d\n", (int)prevC, (int)c);
fprintf(stderr, "seqind: %d\n", seqInd);
fprintf(stderr, "Invalid format found: %c%c\n", prevC, c);
exit(1);
}
}
prevC = c;
}
}
bool AudioFormatWriter::writeFromAudioSampleBuffer (const AudioSampleBuffer& source, int startSample, int numSamples)
{
jassert (startSample >= 0 && startSample + numSamples <= source.getNumSamples() && source.getNumChannels() > 0);
if (numSamples <= 0)
return true;
HeapBlock<int> tempBuffer;
HeapBlock<int*> chans (numChannels + 1);
chans [numChannels] = 0;
if (isFloatingPoint())
{
for (int i = (int) numChannels; --i >= 0;)
chans[i] = reinterpret_cast<int*> (source.getSampleData (i, startSample));
}
else
{
tempBuffer.malloc (numSamples * numChannels);
for (unsigned int i = 0; i < numChannels; ++i)
{
typedef AudioData::Pointer <AudioData::Int32, AudioData::NativeEndian, AudioData::NonInterleaved, AudioData::NonConst> DestSampleType;
typedef AudioData::Pointer <AudioData::Float32, AudioData::NativeEndian, AudioData::NonInterleaved, AudioData::Const> SourceSampleType;
DestSampleType destData (chans[i] = tempBuffer + i * numSamples);
SourceSampleType sourceData (source.getSampleData ((int) i, startSample));
destData.convertSamples (sourceData, numSamples);
}
}
return write ((const int**) chans.getData(), numSamples);
}
bool AudioFormatWriter::writeFromAudioReader (AudioFormatReader& reader,
int64 startSample,
int64 numSamplesToRead)
{
const int bufferSize = 16384;
AudioSampleBuffer tempBuffer ((int) numChannels, bufferSize);
int* buffers [128] = { 0 };
for (int i = tempBuffer.getNumChannels(); --i >= 0;)
buffers[i] = reinterpret_cast<int*> (tempBuffer.getSampleData (i, 0));
if (numSamplesToRead < 0)
numSamplesToRead = reader.lengthInSamples;
while (numSamplesToRead > 0)
{
const int numToDo = (int) jmin (numSamplesToRead, (int64) bufferSize);
if (! reader.read (buffers, (int) numChannels, startSample, numToDo, false))
return false;
if (reader.usesFloatingPointData != isFloatingPoint())
{
int** bufferChan = buffers;
while (*bufferChan != nullptr)
{
void* const b = *bufferChan++;
if (isFloatingPoint())
FloatVectorOperations::convertFixedToFloat ((float*) b, (int*) b, 1.0f / 0x7fffffff, numToDo);
else
convertFloatsToInts ((int*) b, (float*) b, numToDo);
}
}
if (! write (const_cast <const int**> (buffers), numToDo))
return false;
numSamplesToRead -= numToDo;
startSample += numToDo;
}
return true;
}
bool AudioFormatWriter::writeFromAudioSource (AudioSource& source,
int numSamplesToRead,
const int samplesPerBlock)
{
const int maxChans = 128;
AudioSampleBuffer tempBuffer (getNumChannels(), samplesPerBlock);
int* buffers [maxChans];
while (numSamplesToRead > 0)
{
const int numToDo = jmin (numSamplesToRead, samplesPerBlock);
AudioSourceChannelInfo info;
info.buffer = &tempBuffer;
info.startSample = 0;
info.numSamples = numToDo;
info.clearActiveBufferRegion();
source.getNextAudioBlock (info);
int i;
for (i = maxChans; --i >= 0;)
buffers[i] = 0;
for (i = tempBuffer.getNumChannels(); --i >= 0;)
buffers[i] = (int*) tempBuffer.getSampleData (i, 0);
if (! isFloatingPoint())
{
int** bufferChan = buffers;
while (*bufferChan != 0)
{
int* b = *bufferChan++;
// float -> int
for (int j = numToDo; --j >= 0;)
{
const double samp = *(const float*) b;
if (samp <= -1.0)
*b++ = INT_MIN;
else if (samp >= 1.0)
*b++ = INT_MAX;
else
*b++ = roundToInt (INT_MAX * samp);
}
}
}
if (! write ((const int**) buffers, numToDo))
return false;
numSamplesToRead -= numToDo;
}
return true;
}
bool AudioFormatWriter::writeFromFloatArrays (const float* const* channels, int numSourceChannels, int numSamples)
{
if (numSamples <= 0)
return true;
if (isFloatingPoint())
return write ((const int**) channels, numSamples);
int* chans[256];
int scratch[4096];
jassert (numSourceChannels < numElementsInArray (chans));
const int maxSamples = (int) (numElementsInArray (scratch) / numSourceChannels);
for (int i = 0; i < numSourceChannels; ++i)
chans[i] = scratch + (i * maxSamples);
chans[numSourceChannels] = nullptr;
int startSample = 0;
while (numSamples > 0)
{
auto numToDo = jmin (numSamples, maxSamples);
for (int i = 0; i < numSourceChannels; ++i)
convertFloatsToInts (chans[i], channels[i] + startSample, numToDo);
if (! write ((const int**) chans, numToDo))
return false;
startSample += numToDo;
numSamples -= numToDo;
}
return true;
}
FloatingPointType::FloatingPointType(const Type& t) throw(IllegalArgumentException) :
Type(t) {
PrettyCheckArgument(isNull() || isFloatingPoint(), this);
}
void printAttributes(std::ostream & out, const Node * n) {
out << "[";
auto names = n->attributeNames();
int i = 0;
for(auto name : names) {
if(i++ > 0)
out << ", ";
out << name.toString() <<"=";
switch(n->kindOf(name)) {
case AttributeKind::f:
out << n->f(name);
break;
case AttributeKind::fs:
printPrimList(out,n->fs(name));
break;
case AttributeKind::i:
out << n->i(name);
break;
case AttributeKind::is:
printPrimList(out,n->is(name));
break;
case AttributeKind::s:
out << n->s(name);
break;
case AttributeKind::ss:
printPrimList(out,n->ss(name));
break;
case AttributeKind::t:
{
at::Tensor t = n->t(name);
// 1-elem tensors are usually boxed scalars, so print them like it
if (t.numel() == 1) {
auto scalar = at::Scalar(t.view({})).local();
out << "{";
if (scalar.isFloatingPoint()) {
out << scalar.toDouble();
} else {
out << scalar.toLong();
}
out << "}";
} else if (t.numel() <= max_tensor_display_size) {
// TODO: This is awful code. Also it doesn't work on Windows.
std::ostringstream tensor_ss;
tensor_ss << t;
std::string tensor_s{tensor_ss.str()};
// Remove newlines
std::replace(tensor_s.begin(), tensor_s.end(), '\n', ' ');
out << tensor_s;
} else {
out << "<Tensor>";
}
break;
}
case AttributeKind::ts:
out << "[<Tensors>]";
break;
case AttributeKind::g:
out << "<Graph>";
break;
case AttributeKind::gs:
out << "[<Graphs>]";
break;
}
}
out << "]";
}
bool Type::isArithmetic() const {
return isIntegral() || isFloatingPoint();
}
bool AudioFormatWriter::writeFromAudioReader (AudioFormatReader& reader,
int64 startSample,
int64 numSamplesToRead)
{
const int bufferSize = 16384;
AudioSampleBuffer tempBuffer ((int) numChannels, bufferSize);
int* buffers [128] = { 0 };
for (int i = tempBuffer.getNumChannels(); --i >= 0;)
buffers[i] = reinterpret_cast<int*> (tempBuffer.getSampleData (i, 0));
if (numSamplesToRead < 0)
numSamplesToRead = reader.lengthInSamples;
while (numSamplesToRead > 0)
{
const int numToDo = (int) jmin (numSamplesToRead, (int64) bufferSize);
if (! reader.read (buffers, (int) numChannels, startSample, numToDo, false))
return false;
if (reader.usesFloatingPointData != isFloatingPoint())
{
int** bufferChan = buffers;
while (*bufferChan != nullptr)
{
int* b = *bufferChan++;
if (isFloatingPoint())
{
// int -> float
const double factor = 1.0 / std::numeric_limits<int>::max();
for (int i = 0; i < numToDo; ++i)
reinterpret_cast<float*> (b)[i] = (float) (factor * b[i]);
}
else
{
// float -> int
for (int i = 0; i < numToDo; ++i)
{
const double samp = *(const float*) b;
if (samp <= -1.0)
*b++ = std::numeric_limits<int>::min();
else if (samp >= 1.0)
*b++ = std::numeric_limits<int>::max();
else
*b++ = roundToInt (std::numeric_limits<int>::max() * samp);
}
}
}
}
if (! write (const_cast <const int**> (buffers), numToDo))
return false;
numSamplesToRead -= numToDo;
startSample += numToDo;
}
return true;
}
bool VariantValue::isArithmetical() const
{
return isIntegral() || isFloatingPoint();
}
bool AudioFormatWriter::writeFromAudioReader (AudioFormatReader& reader,
int64 startSample,
int64 numSamplesToRead)
{
const int bufferSize = 16384;
const int maxChans = 128;
AudioSampleBuffer tempBuffer (reader.numChannels, bufferSize);
int* buffers [maxChans];
for (int i = maxChans; --i >= 0;)
buffers[i] = 0;
if (numSamplesToRead < 0)
numSamplesToRead = reader.lengthInSamples;
while (numSamplesToRead > 0)
{
const int numToDo = (int) jmin (numSamplesToRead, (int64) bufferSize);
for (int i = tempBuffer.getNumChannels(); --i >= 0;)
buffers[i] = (int*) tempBuffer.getSampleData (i, 0);
if (! reader.read (buffers, maxChans, startSample, numToDo, false))
return false;
if (reader.usesFloatingPointData != isFloatingPoint())
{
int** bufferChan = buffers;
while (*bufferChan != 0)
{
int* b = *bufferChan++;
if (isFloatingPoint())
{
// int -> float
const double factor = 1.0 / INT_MAX;
for (int i = 0; i < numToDo; ++i)
((float*)b)[i] = (float) (factor * b[i]);
}
else
{
// float -> int
for (int i = 0; i < numToDo; ++i)
{
const double samp = *(const float*) b;
if (samp <= -1.0)
*b++ = INT_MIN;
else if (samp >= 1.0)
*b++ = INT_MAX;
else
*b++ = roundToInt (INT_MAX * samp);
}
}
}
}
if (! write ((const int**) buffers, numToDo))
return false;
numSamplesToRead -= numToDo;
startSample += numToDo;
}
return true;
}
std::vector<uint8_t> BsonSerializer::writeDocument(Bundle& value) const
{
std::vector<uint8_t> res;
BufferWriter wrt(res);
// Document length
wrt.writeInt32(0);
for (auto& elem : value)
{
auto info = elem.second.type_info();
if (info.isArithmetic())
{
if (info.isFloatingPoint())
{
wrt.writeUInt8(0x01); // double
wrt.writeCString(elem.first);
wrt.writeDouble(elem.second.as<double>());
}
else {
wrt.writeUInt8(0x12); // int64
wrt.writeCString(elem.first);
wrt.writeInt64(elem.second.as<int64_t>());
}
}
else if (elem.second.isSerializable())
{
wrt.writeUInt8(0x03);
wrt.writeCString(elem.first);
Bundle v = elem.second.serialize().as<Bundle>();
auto val = this->writeDocument(v);
wrt.writeBytes(val.data(), val.size());
}
else if (elem.second.isType<std::vector<AnyValue>>())
{
wrt.writeUInt8(0x04);
wrt.writeCString(elem.first);
std::vector<AnyValue> v = elem.second.as<std::vector<AnyValue>>();
Bundle b;
for (size_t i = 0; i < v.size(); i++) b.set(std::to_string(i), v[i]);
auto val = this->writeDocument(b);
wrt.writeBytes(val.data(), val.size());
}
else if (elem.second.isType<std::vector<uint8_t>>())
{
wrt.writeUInt8(0x05);
wrt.writeCString(elem.first);
std::vector<uint8_t> v = elem.second.as<std::vector<uint8_t>>();
if (v.size() > INT32_MAX) throw std::runtime_error("Data too large");
wrt.writeInt32((int32_t)v.size()); // Binary size
wrt.writeUInt8(0x00); // Subtype
wrt.writeBytes(v.data(), v.size()); // Data
}
else if (elem.second.isType<bool>())
{
wrt.writeUInt8(0x08);
wrt.writeCString(elem.first);
bool v = elem.second.as<bool>();
wrt.writeUInt8(v ? 0x01 : 0x00);
}
else if (elem.second.isType<std::nullptr_t>())
{
wrt.writeUInt8(0x0A);
wrt.writeCString(elem.first);
}
else if (elem.second.isConvertibleTo<std::string>())
{
wrt.writeUInt8(0x02);
wrt.writeCString(elem.first);
std::string v = elem.second.as<std::string>();
if (v.size() > INT32_MAX - 1) throw std::runtime_error("String too large");
wrt.writeInt32((int32_t)v.size() + 1);
wrt.writeCString(v);
}
}
wrt.writeUInt8(0x00);
wrt.setPosition(0);
wrt.setOverwrite(true);
// Update Size value
if (wrt.getSize() > INT32_MAX) throw std::runtime_error("Document to large");
wrt.writeInt32((int32_t)wrt.getSize());
return res;
}
Json::Value JsonSerializer::toValue(AnyValue val) const
{
auto info = val.type_info();
if (val.isType<bool>())
{
bool v = val.as<bool>();
return Json::Value(v);
}
else if (info.isIntegral())
{
if (info.isUnsigned())
{
uint64_t v = val.as<uint64_t>();
return Json::Value((Json::Value::UInt64)v);
}
else {
int64_t v = val.as<int64_t>();
return Json::Value((Json::Value::Int64)v);
}
}
else if (info.isFloatingPoint())
{
double v = val.as<double>();
return Json::Value(v);
}
else if (val.isType<std::vector<AnyValue>>())
{
Json::Value res = Json::arrayValue;
std::vector<AnyValue> v = val.as < std::vector<AnyValue>>();
for (AnyValue any : v)
res.append(this->toValue(any));
return res;
}
else if (val.isType<Bundle>())
{
Json::Value res = Json::objectValue;
Bundle b = val.as<Bundle>();
for (const auto& val : b)
{
res[val.first] = this->toValue(val.second);
}
return res;
}
else if (val.isType<std::nullptr_t>())
{
return Json::nullValue;
}
else if (val.isSerializable())
{
return this->toValue(val.serialize());
}
else if (val.isConvertibleTo<std::string>())
{
std::string v = val.as<std::string>();
return Json::Value(v);
}
else
{
throw std::logic_error("Type is not convertible.");
}
}
