void JuceBoxAudioProcessor::loadSound() { Logger::writeToLog("- loadSound()."); synth.clearSounds(); if (!sampleFile.existsAsFile()) { Logger::writeToLog("\"" + sampleFile.getFullPathName() + "\" doesn't exist."); return; } AudioFormatReader* reader = formatManager.createReaderFor(sampleFile); if (reader == NULL) { Logger::writeToLog("No reader for \"" + sampleFile.getFullPathName() + "\"."); return; } Logger::writeToLog("Format: " + reader->getFormatName()); Logger::writeToLog("Sample rate: " + String(reader->sampleRate)); Logger::writeToLog("length: " + String(reader->lengthInSamples)); Logger::writeToLog("numChannels: " + String(reader->numChannels)); BigInteger notes; notes.setRange(0, 127, true); SamplerSound* sound = new SamplerSound( sampleFile.getFileNameWithoutExtension(), *reader, notes, 72 /* C5 == middle C above A-440 */, 0.0, 0.01, 20.0 /* max time, hopefully 20s is enough for any sound */); synth.addSound(sound); delete reader; }
SampleItem::SampleItem(const String &filename) { this->filename = filename; File file(filename); if (file.exists()) { shortname = file.getFileNameWithoutExtension(); FileInputStream *stream = new FileInputStream(file); WavAudioFormat format; AudioFormatReader *reader = format.createReaderFor(stream, false); if (reader) { formatName = reader->getFormatName(); sampleRate = (int)reader->sampleRate; size = (int)reader->lengthInSamples; bits = reader->bitsPerSample; delete reader; } else { sampleRate = 0; size = 0; bits = 0; } } playing = false; }
//============================================================================== MainContentComponent::MainContentComponent():readAheadThread("read Ahead thread"){ // Format manager audioFormatManager.registerBasicFormats(); // Device manager audioDeviceManager = new AudioDeviceManager(); audioDeviceManager->initialise(0, 2, 0, true); readAheadThread.startThread(3); // Read file File sfile (File::getSpecialLocation (File::userDocumentsDirectory).getChildFile("lyd3_000_ortf_48k.wav")); AudioFormatReader* audioFormatReader = audioFormatManager.createReaderFor(sfile); ScopedPointer<AudioSampleBuffer> audioBuffer = new AudioSampleBuffer(1, audioFormatReader->lengthInSamples); //audioBuffer para leer archivo wav audioFormatReader->read(audioBuffer, 0, audioFormatReader->lengthInSamples, 0, true, false); // Cambiar Fs del AudioDevice segun sea la del archivo wav juce::AudioDeviceManager::AudioDeviceSetup newAudioSetup; audioDeviceManager->getAudioDeviceSetup(newAudioSetup); newAudioSetup.sampleRate=audioFormatReader->sampleRate; audioDeviceManager->setAudioDeviceSetup(newAudioSetup, true); //Playback preparation audioFormatReaderSource = new AudioFormatReaderSource(audioFormatReader, true); audioTransportSource.setSource(audioFormatReaderSource, 32768, &readAheadThread, 0, 2); //el 0 es para que no haga resamplig.... audioSourcePlayer.setSource(&audioTransportSource); //..depende de haber cambiado Fs en AudioDevice audioDeviceManager->addAudioCallback(&audioSourcePlayer); //Playback start audioTransportSource.start(); Logger::writeToLog ("Total length: --> " + String(audioFormatReader->lengthInSamples)); int bandas=10; for (int i=0;i<bandas;i++) { Buffer* buffer = new Buffer(audioFormatReader->lengthInSamples); filteredAudioArray.add(buffer); //filteredAudioArray es un OwnedArray y debe ser declarado como una variable de la clase para que } //le pertenezca y sea la clase la que lo borre. filterBank = new FilterBank(bandas); //La clase filterBank necesita un WritePointer a un canal de un AudioSampleBuffer donde esta la entrada... filterBank->setCoeficientes(); //y un puntero a un OwnedArray<Buffer> del tamaño del filterBank donde quedan diferentes salidas filtradas filterBank->processSamples(audioBuffer->getWritePointer(0),&filteredAudioArray, audioFormatReader->lengthInSamples); const int N = 1; //downsamplig rate const int M = 1; //length fraction bufferWaveform = new Buffer(audioFormatReader->lengthInSamples/(M*N)); //buffer para downSamplig con el que se pinta waveForm audioDownSamplig(audioBuffer,bufferWaveform,N,M); addAndMakeVisible(tabsComponent = new TabbedComponent(TabbedButtonBar::TabsAtTop)); tabsComponent->addTab("Respuesta al Impulso", Colour(0xff2f2f2f), new AudioWaveForm(bufferWaveform,true), true); for(int i=0;i<bandas;i++){ tabsComponent->addTab("Filtered IR", Colour(0xff2f2f2f), new AudioWaveForm(filteredAudioArray.getUnchecked(i),true), true); } setSize (1200, 400); }
void CtrlrPanelResourceEditor::showResourceInfo(const int resourceIndex) { CtrlrPanelResource *res = resources[resourceIndex]; if (res == nullptr) return; String message; message << "Load time: " + res->getLoadedTime().toString(true, true, true, true) + "\n"; message << "Data file: " + res->getFile().getFullPathName() + "\n"; message << "Source file: " + res->getSourceFile().getFullPathName() + "\n"; message << "Source hash: " + STR(res->getHashCode()) + "\n"; AudioFormatReader *afr = res->asAudioFormat(); if (afr) { message << "Type: Audio\n"; message << "Format name: " << afr->getFormatName() << "\n"; message << "Sample rate: " << afr->sampleRate << "\n"; message << "Bits per sample: " << ((int)afr->bitsPerSample) << "\n"; message << "Length in samples: " << afr->lengthInSamples << "\n"; message << "Number of channels: " << ((int)afr->numChannels) << "\n"; message << "Metadata:\n"; message << "\t" << afr->metadataValues.getDescription(); } if (!res->asImage().isNull()) { Image i = res->asImage(); message << "Type: Image\n"; message << "Width: " + STR(i.getWidth()) + "\n"; message << "Height: " + STR(i.getHeight()) + "\n"; message << "Has alpha: " + STR(i.hasAlphaChannel()) + "\n"; } DialogWindow::LaunchOptions lo; Label *l = new Label ("", message); l->setSize (400, 150); l->setJustificationType (Justification::centred); l->setFont (Font(12.0f)); lo.content.set(l, true); lo.componentToCentreAround = this; lo.dialogBackgroundColour = Colours::whitesmoke; lo.dialogTitle = "Resource information"; lo.resizable = true; lo.useBottomRightCornerResizer = false; lo.useNativeTitleBar = true; lo.launchAsync(); }
SamplerSound::SamplerSound (const String& name_, AudioFormatReader& source, const BigInteger& midiNotes_, const int midiNoteForNormalPitch, const double attackTimeSecs, const double releaseTimeSecs, const double maxSampleLengthSeconds) : name (name_), midiNotes (midiNotes_), midiRootNote (midiNoteForNormalPitch) { sourceSampleRate = source.sampleRate; if (sourceSampleRate <= 0 || source.lengthInSamples <= 0) { length = 0; attackSamples = 0; releaseSamples = 0; } else { length = jmin ((int) source.lengthInSamples, (int) (maxSampleLengthSeconds * sourceSampleRate)); data = new AudioSampleBuffer (jmin (2, (int) source.numChannels), length + 4); source.read (data, 0, length + 4, 0, true, true); attackSamples = roundToInt (attackTimeSecs * sourceSampleRate); releaseSamples = roundToInt (releaseTimeSecs * sourceSampleRate); } }
SamplerSound::SamplerSound (const String& soundName, AudioFormatReader& source, const BigInteger& notes, int midiNoteForNormalPitch, double attackTimeSecs, double releaseTimeSecs, double maxSampleLengthSeconds) : name (soundName), sourceSampleRate (source.sampleRate), midiNotes (notes), midiRootNote (midiNoteForNormalPitch) { if (sourceSampleRate > 0 && source.lengthInSamples > 0) { length = jmin ((int) source.lengthInSamples, (int) (maxSampleLengthSeconds * sourceSampleRate)); data = new AudioSampleBuffer (jmin (2, (int) source.numChannels), length + 4); source.read (data, 0, length + 4, 0, true, true); attackSamples = roundToInt (attackTimeSecs * sourceSampleRate); releaseSamples = roundToInt (releaseTimeSecs * sourceSampleRate); } }
static void readChannels (AudioFormatReader& reader, int** chans, AudioBuffer<float>* buffer, int startSample, int numSamples, int64 readerStartSample, int numTargetChannels) { for (int j = 0; j < numTargetChannels; ++j) chans[j] = reinterpret_cast<int*> (buffer->getWritePointer (j, startSample)); chans[numTargetChannels] = nullptr; reader.read (chans, numTargetChannels, readerStartSample, numSamples, true); }
bool SFZSample::load(AudioFormatManager* formatManager) { AudioFormatReader* reader = formatManager->createReaderFor(file); if (reader == NULL) return false; sampleRate = reader->sampleRate; sampleLength = reader->lengthInSamples; // Read some extra samples, which will be filled with zeros, so interpolation // can be done without having to check for the edge all the time. buffer = new AudioSampleBuffer(reader->numChannels, sampleLength + 4); reader->read(buffer, 0, sampleLength + 4, 0, true, true); StringPairArray* metadata = &reader->metadataValues; int numLoops = metadata->getValue("NumSampleLoops", "0").getIntValue(); if (numLoops > 0) { loopStart = metadata->getValue("Loop0Start", "0").getLargeIntValue(); loopEnd = metadata->getValue("Loop0End", "0").getLargeIntValue(); } delete reader; return true; }
static void readChannels (AudioFormatReader& reader, int** const chans, AudioSampleBuffer* const buffer, const int startSample, const int numSamples, const int64 readerStartSample, const int numTargetChannels) { for (int j = 0; j < numTargetChannels; ++j) chans[j] = reinterpret_cast<int*> (buffer->getSampleData (j, startSample)); chans[numTargetChannels] = nullptr; reader.read (chans, numTargetChannels, readerStartSample, numSamples, true); }
void Sample::update(const String& path, WavAudioFormat& wavAudioFormat) { // Don't load a subsequent sample if a new sample is already loaded (but not yet played). if (_readyToSwap) return; // Find audio file. String fileName(path); fileName = File::addTrailingSeparator(fileName); fileName += _name; fileName += EXT; File file(fileName); Time modification = file.getLastModificationTime(); if (modification <= _lastModification) return; // Read audio file. We only read the left channel, mono is good enough. AudioFormatReader* reader = wavAudioFormat.createReaderFor(file.createInputStream(), true); if (reader == nullptr) return; _lastModification = modification; int64 start = reader->searchForLevel(0, reader->lengthInSamples, SAMPLE_START_THRESHOLD, 1.0, 0); if (start == -1) start = 0; int count = (int)(reader->lengthInSamples - start); _processor->writeTrace(String() << "Loading " << _name << " from disk (skip=" << start << ")"); int newIndex = !_bufferIndex; AudioSampleBuffer* buffer = &(_buffers[newIndex]); buffer->setSize(1, count); reader->read(buffer, 0, count, start, true, false); delete reader; // Done. _readyToSwap = true; }
//============================================================================== MemoryMappedAudioFormatReader::MemoryMappedAudioFormatReader (const File& f, const AudioFormatReader& reader, int64 start, int64 length, int frameSize) : AudioFormatReader (nullptr, reader.getFormatName()), file (f), dataChunkStart (start), dataLength (length), bytesPerFrame (frameSize) { sampleRate = reader.sampleRate; bitsPerSample = reader.bitsPerSample; lengthInSamples = reader.lengthInSamples; numChannels = reader.numChannels; metadataValues = reader.metadataValues; usesFloatingPointData = reader.usesFloatingPointData; }
MelodicSamplerSound::MelodicSamplerSound (String& filePath, const int midiNote, const int beginSamples, const int numSamples) : note(midiNote) { File *file = new File(filePath); FileInputSource *source = new FileInputSource(*file, false); InputStream *stream = source->createInputStream(); AudioFormatReader *reader = mp3Format->createReaderFor(stream, true); sourceSampleRate = reader->sampleRate; attackSamples = 0, releaseSamples = 0; // attackSamples = roundToInt (attackTimeSec * sourceSampleRate); // releaseSamples = roundToInt (releaseTimeSec * sourceSampleRate); if (sourceSampleRate <= 0 || reader->lengthInSamples <= 0) { length = 0; } else { int begin = jmin((int) reader->lengthInSamples - 1, beginSamples); length = jmin ((int) reader->lengthInSamples - begin, numSamples); data = new AudioSampleBuffer (jmin (2, (int) reader->numChannels), length + 4); reader->read (data, 0, length + 4, begin, true, true); } }
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 Mcfx_convolverAudioProcessor::loadIr(AudioSampleBuffer* IRBuffer, const File& audioFile, int channel, double &samplerate, float gain, int offset, int length) { if (!audioFile.existsAsFile()) { std::cout << "ERROR: file does not exist!!" << std::endl; return false; } AudioFormatManager formatManager; // this can read .wav and .aiff formatManager.registerBasicFormats(); AudioFormatReader* reader = formatManager.createReaderFor(audioFile); if (!reader) { std::cout << "ERROR: could not read impulse response file!" << std::endl; return false; } //AudioFormatReader* reader = wavFormat.createMemoryMappedReader(audioFile); int64 ir_length = (int)reader->lengthInSamples-offset; if (ir_length <= 0) { std::cout << "wav file has zero samples" << std::endl; return false; } if (reader->numChannels <= channel) { std::cout << "wav file doesn't have enough channels: " << reader->numChannels << std::endl; return false; } AudioSampleBuffer ReadBuffer(reader->numChannels, ir_length); // create buffer reader->read(&ReadBuffer, 0, ir_length, offset, true, true); // set the samplerate -> maybe we have to resample later... samplerate = reader->sampleRate; //std::cout << "ReadRMS: " << ReadBuffer.getRMSLevel(channel, 0, ir_length) << std::endl; // check if we want a shorter impulse response if (ir_length > length && length != 0) ir_length = length; // copy the wanted channel into our IR Buffer IRBuffer->setSize(1, ir_length); IRBuffer->copyFrom(0, 0, ReadBuffer, channel, 0, ir_length); // scale ir with gain IRBuffer->applyGain(gain); // std::cout << "ReadRMS: " << IRBuffer->getRMSLevel(0, 0, ir_length) << std::endl; delete reader; return true; }
BufferingAudioReader::BufferedBlock::BufferedBlock (AudioFormatReader& reader, int64 pos, int numSamples) : range (pos, pos + numSamples), buffer ((int) reader.numChannels, numSamples) { reader.read (&buffer, 0, numSamples, pos, true, true); }
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; }
void Dictionary::createDictionary(std::string outputDir) { //open output file std::fstream outputFile; outputFile.open(outputDir+"W.txt", std::ios::out); if (!outputFile.is_open()) { std::cout << "Text file open error!"; return; } //prepare to read file AudioFormatManager formatManager; formatManager.registerBasicFormats(); kiss_fft_cfg fwd= kiss_fft_alloc(FFT_SIZE,0,NULL,NULL); // HARD CODING HERE. REQUIRES MODIFICATION float fs = 44100; int nChannels = 2; numSamplesToRead = round(fs*SECS_PER_BLOCK); numSamplesPerBlock = numSamplesToRead/DOWNSAMPLE_RATE; AudioSampleBuffer buffer(nChannels, numSamplesToRead); float* audioBuffer = new float[numSamplesToRead]; for (int track = 21; track<=108; track++) { // ANY BETTER WAYS TO DEAL WITH FILENAMES?? std::string strFileDir = sampleFileFolder + "MAPS_ISOL_NO_M_S0_M"+std::to_string(track)+"_AkPnBcht.wav"; File audioFileS0(strFileDir); AudioFormatReader* reader; if (audioFileS0.exists()) { reader = formatManager.createReaderFor(audioFileS0); } else { strFileDir = sampleFileFolder + "MAPS_ISOL_NO_M_S1_M"+std::to_string(track)+"_AkPnBcht.wav"; File audioFileS1(strFileDir); reader = formatManager.createReaderFor(audioFileS1); } reader->read(&buffer, 0, numSamplesToRead, fs, true, true); float* leftBuffer = buffer.getSampleData(0); float* rightBuffer = buffer.getSampleData(1); for (int i=0; i<numSamplesToRead; i++) { audioBuffer[i] = (leftBuffer[i]+rightBuffer[i])/2; } antiAlias(audioBuffer, numSamplesToRead); for (int i=0; i<numSamplesPerBlock; i++) { audio[i].real( audioBuffer[i*DOWNSAMPLE_RATE]*hammWin(i, numSamplesPerBlock) ); audio[i].imag(0); } for (int i = numSamplesPerBlock; i<FFT_SIZE; i++) { audio[i].real(0); audio[i].imag(0); } kiss_fft(fwd, (kiss_fft_cpx*) audio, (kiss_fft_cpx*)spectrum); for (int i = 0; i<FFT_SIZE/2; i++) { W[i][track-21] = abs(spectrum[i]); //HARD CODING HERE! } delete reader; } delete [] audioBuffer; for(int i = 0; i< FFT_SIZE/2; i++){ for (int j = 0; j<N_NOTES; j++) { // fwrite(&W[i][j], sizeof(float), 1, file); outputFile << W[i][j] << "\t"; } outputFile<<std::endl; } outputFile.close(); }
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; }
static void readMaxLevelsFilteringWithColour (AudioFormatReader &reader, BiquadFilter &filterLow, BiquadFilter &filterLowMid, BiquadFilter &filterHighMid, BiquadFilter &filterHigh, int64 startSampleInFile, int64 numSamples, float& lowestLeft, float& highestLeft, float& lowestRight, float& highestRight, Colour &colourLeft, Colour &colourRight) { if (numSamples <= 0) { lowestLeft = 0; lowestRight = 0; highestLeft = 0; highestRight = 0; colourLeft = Colours::white; colourRight = Colours::white; return; } const int bufferSize = (int) jmin (numSamples, (int64) 4096); HeapBlock<int> tempSpace (bufferSize * 2 + 64); // const int heapBlockSize = bufferSize * 2 + 64; // int tempSpace[heapBlockSize]; int* tempBuffer[3]; tempBuffer[0] = &tempSpace[0];//tempSpace.getData(); tempBuffer[1] = &tempSpace[bufferSize];//tempSpace.getData() + bufferSize; tempBuffer[2] = 0; // HeapBlock<int> filteredBlock (bufferSize * 4); // int* filteredArray[4] = {filteredBlock.getData(), // filteredBlock.getData()+bufferSize, // filteredBlock.getData()+(bufferSize*2), // filteredBlock.getData()+(bufferSize*3)}; const int filteredBlockSize = bufferSize * 4; HeapBlock<int> filteredBlock (filteredBlockSize); //int filteredBlock[filteredBlockSize]; int* filteredArray[4] = {&filteredBlock[0], &filteredBlock[bufferSize], &filteredBlock[bufferSize * 2], &filteredBlock[bufferSize * 3]}; float avgLow = 0.0f, avgMid = 0.0f, avgHigh = 0.0f; if (reader.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); reader.read (tempBuffer, 2, startSampleInFile, numToDo, false); // copy samples to buffers ready to be filtered memcpy(filteredArray[0], tempBuffer[0], sizeof(int)*numToDo); memcpy(filteredArray[1], tempBuffer[0], sizeof(int)*numToDo); memcpy(filteredArray[2], tempBuffer[0], sizeof(int)*numToDo); memcpy(filteredArray[3], tempBuffer[0], sizeof(int)*numToDo); // filter buffers filterLow.processSamples (reinterpret_cast<float*> (filteredArray[0]), numToDo); filterLowMid.processSamples (reinterpret_cast<float*> (filteredArray[1]), numToDo); filterHighMid.processSamples (reinterpret_cast<float*> (filteredArray[2]), numToDo); filterHigh.processSamples (reinterpret_cast<float*> (filteredArray[3]), numToDo); // calculate colour for (int i = 0; i < numToDo; i++) { // avgLow += fabsf((reinterpret_cast<float*>(filteredArray[0]))[i]); // avgMid += fabsf((reinterpret_cast<float*>(filteredArray[1]))[i]); // avgHigh += fabsf((reinterpret_cast<float*>(filteredArray[2]))[i]); float low = fabsf((reinterpret_cast<float*> (filteredArray[0]))[i]); float mid = (fabsf((reinterpret_cast<float*> (filteredArray[1]))[i]) + fabsf((reinterpret_cast<float*>(filteredArray[2]))[i])); float high = fabsf((reinterpret_cast<float*> (filteredArray[3]))[i]); if (low > avgLow) { avgLow = low; } if (mid > avgMid) { avgMid = mid; } if (high > avgHigh) { avgHigh = high; } } 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 (reader.numChannels > 1) { findMinAndMax (reinterpret_cast<float*> (tempBuffer[1]), numToDo, bufMin, bufMax); rmin = jmin (rmin, bufMin); rmax = jmax (rmax, bufMax); } } if (reader.numChannels <= 1) { rmax = lmax; rmin = lmin; } lowestLeft = lmin; highestLeft = lmax; lowestRight = rmin; highestRight = rmax; // avgLow = (avgLow / numToAverage); // avgMid = (avgMid / numToAverage); // avgHigh = (avgHigh / numToAverage); } 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 (! reader.read (tempBuffer, 2, startSampleInFile, numToDo, false)) break; // copy samples to buffers ready to be filtered memcpy (filteredArray[0], tempBuffer[0], sizeof (int) * numToDo); memcpy (filteredArray[1], tempBuffer[0], sizeof (int) * numToDo); memcpy (filteredArray[2], tempBuffer[0], sizeof (int) * numToDo); memcpy (filteredArray[3], tempBuffer[0], sizeof (int) * numToDo); // filter buffers filterLow.processSamples((filteredArray[0]), numToDo); filterLowMid.processSamples((filteredArray[1]), numToDo); filterHighMid.processSamples((filteredArray[2]), numToDo); filterHigh.processSamples((filteredArray[3]), numToDo); // calculate colour for (int i = 0; i < numToDo; i++) { // avgLow += abs(((filteredArray[0]))[i]); // avgMid += abs(((filteredArray[1]))[i]); // avgHigh += abs(((filteredArray[2]))[i]); int low = abs(filteredArray[0][i]); int mid = (abs(filteredArray[1][i]) + abs(filteredArray[2][i])); int high = abs(filteredArray[3][i]); if (low > avgLow) { avgLow = (float) low; } if (mid > avgMid) { avgMid = (float) mid; } if (high > avgHigh) { avgHigh = (float) high; } } numSamples -= numToDo; startSampleInFile += numToDo; for (int j = reader.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 (reader.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(); // avgLow = (avgLow / numToAverage) / (float) std::numeric_limits<int>::max(); // avgMid = (avgMid / numToAverage) / (float) std::numeric_limits<int>::max(); // avgHigh = (avgHigh / numToAverage) / (float) std::numeric_limits<int>::max(); avgLow = avgLow / (float) ::std::numeric_limits<int>::max(); avgMid = avgMid / (float) ::std::numeric_limits<int>::max(); avgHigh = avgHigh / (float) ::std::numeric_limits<int>::max(); } uint8 maxSize = ::std::numeric_limits<uint8>::max(); colourLeft = Colour::fromRGB((uint8) (avgLow * maxSize), (uint8) (avgMid * maxSize * 0.66f), (uint8) (avgHigh * maxSize * 0.33f)); colourRight = colourLeft; }