void AudioThumbnail::addBlock (const int64 startSample, const AudioSampleBuffer& incoming,
int startOffsetInBuffer, int numSamples)
{
jassert (startSample >= 0);
const int firstThumbIndex = (int) (startSample / samplesPerThumbSample);
const int lastThumbIndex = (int) ((startSample + numSamples + (samplesPerThumbSample - 1)) / samplesPerThumbSample);
const int numToDo = lastThumbIndex - firstThumbIndex;
if (numToDo > 0)
{
const int numChans = jmin (channels.size(), incoming.getNumChannels());
const HeapBlock<MinMaxValue> thumbData ((size_t) (numToDo * numChans));
const HeapBlock<MinMaxValue*> thumbChannels ((size_t) numChans);
for (int chan = 0; chan < numChans; ++chan)
{
const float* const sourceData = incoming.getSampleData (chan, startOffsetInBuffer);
MinMaxValue* const dest = thumbData + numToDo * chan;
thumbChannels [chan] = dest;
for (int i = 0; i < numToDo; ++i)
{
float low, high;
const int start = i * samplesPerThumbSample;
findMinAndMax (sourceData + start, jmin (samplesPerThumbSample, numSamples - start), low, high);
dest[i].setFloat (low, high);
}
}
setLevels (thumbChannels, firstThumbIndex, numChans, numToDo);
}
}
static void getStereoMinAndMax (SampleType* const* channels, const int numChannels, const int numSamples,
SampleType& lmin, SampleType& lmax, SampleType& rmin, SampleType& rmax)
{
SampleType bufMin, bufMax;
findMinAndMax (channels[0], numSamples, bufMin, bufMax);
lmax = jmax (lmax, bufMax);
lmin = jmin (lmin, bufMin);
if (numChannels > 1)
{
findMinAndMax (channels[1], numSamples, bufMin, bufMax);
rmax = jmax (rmax, bufMax);
rmin = jmin (rmin, bufMin);
}
else
{
rmax = lmax;
rmin = lmin;
}
}
void AudioSampleBuffer::findMinMax (const int channel,
const int startSample,
int numSamples,
float& minVal,
float& maxVal) const noexcept
{
jassert (isPositiveAndBelow (channel, numChannels));
jassert (startSample >= 0 && startSample + numSamples <= size);
findMinAndMax (channels [channel] + startSample, numSamples, minVal, maxVal);
}
ImageReader::ImageReader(QString filename)
{
std::cout << "loading " << filename.toStdString() << std::endl;
bool success = m_image.load(filename);
if(success){
m_imageData = reinterpret_cast<QRgb *>(m_image.bits());
m_filename = filename;
} else {
std::cout << "Could not read image." << std::endl;
}
findMinAndMax();
}
void Circle::setCoordinates(Point p, ...)
{
m_center = p;
va_list ap;
va_start(ap, p);
m_radius = va_arg(ap, uint);
va_end(ap);
for (int alpha(0); alpha < 360; ++alpha)
{
int x = m_center.x() + static_cast<int>(m_radius*cos(alpha));
int y = m_center.y() + static_cast<int>(m_radius*sin(alpha));
m_vertex.push_back(Point(x, y));
}
findMinAndMax();
}
void AudioFormatReader::readMaxLevels (int64 startSampleInFile,
int64 numSamples,
float& lowestLeft, float& highestLeft,
float& lowestRight, float& highestRight)
{
if (numSamples <= 0)
{
lowestLeft = 0;
lowestRight = 0;
highestLeft = 0;
highestRight = 0;
return;
}
const int bufferSize = (int) jmin (numSamples, (int64) 4096);
HeapBlock<int> tempSpace ((size_t) bufferSize * 2 + 64);
int* tempBuffer[3];
tempBuffer[0] = tempSpace.getData();
tempBuffer[1] = tempSpace.getData() + bufferSize;
tempBuffer[2] = 0;
if (usesFloatingPointData)
{
float lmin = 1.0e6f;
float lmax = -lmin;
float rmin = lmin;
float rmax = lmax;
while (numSamples > 0)
{
const int numToDo = (int) jmin (numSamples, (int64) bufferSize);
read (tempBuffer, 2, startSampleInFile, numToDo, false);
numSamples -= numToDo;
startSampleInFile += numToDo;
float bufMin, bufMax;
findMinAndMax (reinterpret_cast<float*> (tempBuffer[0]), numToDo, bufMin, bufMax);
lmin = jmin (lmin, bufMin);
lmax = jmax (lmax, bufMax);
if (numChannels > 1)
{
findMinAndMax (reinterpret_cast<float*> (tempBuffer[1]), numToDo, bufMin, bufMax);
rmin = jmin (rmin, bufMin);
rmax = jmax (rmax, bufMax);
}
}
if (numChannels <= 1)
{
rmax = lmax;
rmin = lmin;
}
lowestLeft = lmin;
highestLeft = lmax;
lowestRight = rmin;
highestRight = rmax;
}
else
{
int lmax = std::numeric_limits<int>::min();
int lmin = std::numeric_limits<int>::max();
int rmax = std::numeric_limits<int>::min();
int rmin = std::numeric_limits<int>::max();
while (numSamples > 0)
{
const int numToDo = (int) jmin (numSamples, (int64) bufferSize);
if (! read (tempBuffer, 2, startSampleInFile, numToDo, false))
break;
numSamples -= numToDo;
startSampleInFile += numToDo;
for (int j = (int) numChannels; --j >= 0;)
{
int bufMin, bufMax;
findMinAndMax (tempBuffer[j], numToDo, bufMin, bufMax);
if (j == 0)
{
lmax = jmax (lmax, bufMax);
lmin = jmin (lmin, bufMin);
}
else
{
rmax = jmax (rmax, bufMax);
rmin = jmin (rmin, bufMin);
}
}
}
if (numChannels <= 1)
{
rmax = lmax;
rmin = lmin;
}
lowestLeft = lmin / (float) std::numeric_limits<int>::max();
highestLeft = lmax / (float) std::numeric_limits<int>::max();
lowestRight = rmin / (float) std::numeric_limits<int>::max();
highestRight = rmax / (float) std::numeric_limits<int>::max();
}
}
static inline void getChannelMinAndMax (SampleType* channel, const int numSamples, SampleType& mn, SampleType& mx)
{
findMinAndMax (channel, numSamples, mn, mx);
}
