//Encodes the audio data into a WAV file
void coder::encode(AudioData * data, string filename){
ofstream audioFile(filename, ios::binary);
if(audioFile.is_open()){
audioFile.write(data->getRIFF(), 4);
int fileSize = data->getFileSize();
audioFile.write((char *)&fileSize, 4);
audioFile.write(data->getFileType(), 4);
audioFile.write(data->getFormat(), 4);
unsigned int infoSize = data->getFormatInfoSize();
audioFile.write((char *)&infoSize, 4);
audioFile.write(data->getFormatInfo(), infoSize);
audioFile.write(data->getDataChunk(), 4);
unsigned int dataSize = data->getDataSize();
audioFile.write((char *)&dataSize, 4);
short ** channelData = data->getChannelData();
short * combinedData = combineChannels(channelData, data->getChannels(), data->getNumberOfSamples());
audioFile.write((char *)combinedData, dataSize);
audioFile.close();
}
}
AudioFilePlayer::AudioFilePlayer(const String& path)
: currentAudioFileSource(0),
sampleRate(0.0),
reciprocalSampleRate(0.0)
{
File audioFile(path);
setFile(audioFile);
}
void PlayerComponent::buttonClicked (Button* buttonThatWasClicked)
{
if (buttonThatWasClicked == browseButton)
{
FileChooser fileChooser(T("Select an audio file to open..."),
_lastWorkingDirectory,
_audioFormatManager.getWildcardForAllFormats(),
false);
if(fileChooser.browseForFileToOpen())
{
File audioFile(fileChooser.getResult());
_lastWorkingDirectory = audioFile.getParentDirectory();
AudioFormatReader *fileReader = _audioFormatManager.createReaderFor(audioFile);
if(fileReader)
{
_transportSource.stop();
_transportSource.setSource(0);
filenameLabel->setText(audioFile.getFileName(), false);
delete _fileReaderSource;
_fileReaderSource = new AudioFormatReaderSource(fileReader, true);
_fileReaderSource->setLooping(loopButton->getToggleState());
_transportSource.setSource(_fileReaderSource, 32768, fileReader->sampleRate);
_transportSource.setPosition(.0f);
_totalTime = double(fileReader->lengthInSamples) / double(fileReader->sampleRate);
timeSlider->setRange(.0, _totalTime, 1.);
timeSlider->setValue(.0, false, false);
setCurrentTime();
}
}
}
else if (buttonThatWasClicked == playButton)
{
if(_transportSource.isPlaying())
_transportSource.stop();
else
_transportSource.start();
}
else if (buttonThatWasClicked == stopButton)
{
_transportSource.stop();
_transportSource.setPosition(0);
setCurrentTime();
}
else if (buttonThatWasClicked == loopButton)
{
if(_fileReaderSource)
_fileReaderSource->setLooping(loopButton->getToggleState());
}
}
QString AudioOutputPrivate::distanceAudioFile( qreal dest )
{
if ( dest > 0.0 && dest < 900.0 ) {
qreal minDistance = 0.0;
int targetDistance = 0;
QVector<int> distances;
distances << 50 << 80 << 100 << 200 << 300 << 400 << 500 << 600 << 700 << 800;
foreach( int distance, distances ) {
QString file = audioFile( QString::number( distance ) );
qreal currentDistance = qAbs( distance - dest );
if ( !file.isEmpty() && ( minDistance == 0.0 || currentDistance < minDistance ) ) {
minDistance = currentDistance;
targetDistance = distance;
}
}
AudioBuffer::AudioBuffer(const String& filename)
{
this->filename = filename;
alBuffer = 0;
File audioFile( filename, FILE_READ );
char text[5];
text[4] = '\0';
//RIFF
audioFile.ReadBytes( text, 4 );
if( String( text ) != "RIFF" ) return;
audioFile.Seek( audioFile.Pos() + 4 );
//WAVE
audioFile.ReadBytes( text, 4 );
if( String( text ) != "WAVE" ) return;
//FMT
audioFile.ReadBytes( text, 4 );
if( String( text ) != "fmt " ) return;
audioFile.Seek( audioFile.Pos() + 4 ); //skip subChunkSize y audioFormat
short audioFormat = audioFile.ReadInt16();
short channels = audioFile.ReadInt16();
int sampleRate = audioFile.ReadInt();
audioFile.Seek( audioFile.Pos() + BLOCK_SIZE_TO_SKIP ); // salta hasta ParamsSize o data
if( audioFormat != 16 && audioFormat != 1 ) audioFile.Seek( audioFile.ReadInt16() + audioFile.Pos() );
while( ( String( text ) != "data" ) )
{
audioFile.ReadBytes( text, 4 );
if( String( text ) != "data" )
{
audioFile.Seek( audioFile.ReadInt() + audioFile.Pos() );
}
}
int bufferSize = audioFile.ReadInt();
char* buffer = (char*) malloc( bufferSize );
audioFile.ReadBytes( buffer, bufferSize );
alGenBuffers( 1, &alBuffer );
alBufferData( alBuffer, channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16, buffer, bufferSize, sampleRate );
free( buffer );
}
void FileListModel::addFile(const QString &filePath)
{
QFileInfo fileInfo(filePath);
const QString key = MAKE_KEY(fileInfo.canonicalFilePath());
const bool flag = (!m_blockUpdates);
if(!m_fileStore.contains(key))
{
AudioFileModel audioFile(fileInfo.canonicalFilePath());
audioFile.metaInfo().setTitle(fileInfo.baseName());
if(flag) beginInsertRows(QModelIndex(), m_fileList.count(), m_fileList.count());
m_fileStore.insert(key, audioFile);
m_fileList.append(key);
if(flag) endInsertRows();
emit rowAppended();
}
}
int ACDAudio::run(void* pArg)
{
Os::Logger::instance().log(FAC_ACD, gACD_DEBUG, "ACDAudio::run - starting get from: %s", mUriString.data());
HttpMessage *pGetRequest = new HttpMessage;
pGetRequest->get(mUri, HTTP_GET_TIMEOUT);
UtlString status;
pGetRequest->getResponseStatusText(&status);
if (status == "OK") {
UtlString audioData;
ssize_t audioLength;
const HttpBody* pResponseBody = pGetRequest->getBody();
pResponseBody->getBytes(&audioData, &audioLength);
Os::Logger::instance().log(FAC_ACD, gACD_DEBUG, "ACDAudio::run - received %zd bytes from: %s\n",
audioLength, mUriString.data());
// Now save the downloaded audio to a local file
size_t writeLength;
OsFile audioFile(mAudioPath);
if (audioFile.open(OsFile::CREATE) != OS_SUCCESS) {
Os::Logger::instance().log(FAC_ACD, PRI_ERR, "ACDAudio::run - "
"Unable to create audio file: %s", mAudioPath.data());
}
else {
audioFile.write(audioData, audioLength, writeLength);
audioFile.close();
}
}
else {
Os::Logger::instance().log(FAC_ACD, PRI_ERR, "ACDAudio::run - failed get from: %s", mUriString.data());
}
delete pGetRequest;
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 4) {
std::cout << "not enough arguments" << std::endl;
return 1;
}
AudioFile audioFile(argv[1]);
Synthesizer synth(44100, 10, 16000);
std::cout << "Input file information:\nSamples: " << audioFile.getFrameCount()
<< "\nSample rate: " << audioFile.getSampleRate()
<< "\nChannels: " << audioFile.getChannelCount() << std::endl;
AudioProcessorPlugin audioProcessor(& synth, argv[3], argc - 4, argv + 4);
SF_INFO outfileInfo = { 0 };
outfileInfo.samplerate = audioProcessor.getSampleRate();
outfileInfo.channels = audioProcessor.getChannelCount();
outfileInfo.format = SF_FORMAT_WAV | SF_FORMAT_PCM_16;
SNDFILE * outFile = sf_open(argv[2], SFM_WRITE, & outfileInfo);
if (outFile == NULL) {
std::cerr << "Failed to create/open output file '" << argv[2] << "': " << sf_strerror(outFile) << std::endl;
return 1;
}
std::vector<float> frameBuffer;
bool ok = true;
unsigned int framesRead = audioProcessor.getFrames(frameBuffer);
while (framesRead > 0) {
const sf_count_t framesWritten = sf_write_float(outFile, &frameBuffer[0], framesRead);
if (framesWritten != framesRead) {
std::cout << "Failed to write frames to output file" << std::endl;
ok = false;
break;
}
framesRead = audioProcessor.getFrames(frameBuffer);
}
sf_close(outFile);
return ok ? 0 : 1;
}
void AudioStreamingServer::Serve(const std::shared_ptr<ISocket>& clientSocket)
{
try {
char recvBuffer[DEFAULT_BUFFER_SIZE];
int read = clientSocket->Receive(recvBuffer, DEFAULT_BUFFER_SIZE);
HttpRequest request(recvBuffer, read);
std::string requestUrl = httpExtractor->ExtractGET(request);
requestUrl = urlCodec->DecodeURL(requestUrl);
const char* songsearch = "/songsearch/";
if(requestUrl.find(songsearch) == 0) {
std::string keyword = requestUrl.substr(strlen(songsearch));
SendMediaList(clientSocket, keyword, httpExtractor->ExtractHOST(request));
} else if(audioLibrary->FileExists(requestUrl.substr(1))) {
std::ifstream audioFile(audioLibrary->GetFullPath(requestUrl), std::ifstream::binary);
if(audioFile.is_open()) {
std::string extension = FindExtension(requestUrl);
std::transform(extension.begin(), extension.end(), extension.begin(), tolower);
StreamFile(clientSocket, audioFile, EXTENSION_TO_CONTENT_TYPE[extension]);
} else {
SendNotFound(clientSocket);
}
} else {
SendNotFound(clientSocket);
}
} catch(const GenericAudioStreamerException& e) {
std::lock_guard<std::mutex> guard(stderrMutex);
std::cerr << e.what();
} catch(const IHttpRequestExtractor::HttpExtractionException& e) {
HttpResponse response(HTTP_1_1, BAD_REQUEST, NONE, 0);
SendResponseHeader(clientSocket, response);
}
}
void TrackComponent::mouseDown(const MouseEvent &e) {
ModifierKeys modifiers = ModifierKeys::getCurrentModifiersRealtime();
int posX;
// check the mod keys ..
if (modifiers.isPopupMenu() || modifiers.isCtrlDown())
{
ScopedPointer<PopupMenu> trackMenu_ = new PopupMenu();
trackMenu_->clear();
trackMenu_->addCommandItem(&_commands, MainWindow::showMixer);
trackMenu_->addItem(1, "Add Region", true);
MouseEvent ev = e.getEventRelativeTo(this);
for(auto region : _regionComponents)
{
posX = ev.x;
region->setBroughtToFrontOnMouseClick(true);
if(region->getPositionX() < posX && posX < (region->getPositionX() + region->getRegionWidth()))
{
trackMenu_->addItem(2, "Remove Region", true);
}
}
switch (trackMenu_->show())
{
case 1:
{
FileChooser chooser("Select an audio file to add...",
File::nonexistent,
"*.wav; *aif; *.flac");
if (chooser.browseForFileToOpen()) {
File audioFile(chooser.getResult());
const String fileString = audioFile.getFullPathName();
String format;
if (fileString.contains(".wav"))
format = "WAV";
else if (fileString.contains(".aif") || fileString.contains(".aiff"))
format = "AIFF";
else if (fileString.contains(".flac"))
format = "FLAC";
AudioFormatManager formatManager;
formatManager.registerBasicFormats();
AudioFormatReader* reader = formatManager.createReaderFor(audioFile);
Audio::Region* region = new Audio::SampleRegion(reader, 1, &audioFile);
Point<int> position = e.getPosition();
int x = position.getX();
if (x > _mixerOffset)
{
int64 samplesRange = secondsToSamples(100, _sampleRate);
int64 positionSamples = pixelsToSamples(x - _mixerOffset, 100 * _pixelsPerClip, samplesRange);
_track->add(positionSamples, region);
createRegionGUI(x, region, formatManager, audioFile);
getParentComponent()->resized();
}
else if (x < _mixerOffset)
{
_track->add(0, region);
createRegionGUI(_mixerOffset, region, formatManager, audioFile);
getParentComponent()->resized();
}
}
}
break;
case 2:
{
CriticalSection critical;
critical.enter();
for(size_t i = 0; i < _regionComponents.size(); ++i)
{
Rectangle<int> bounds_ = _regionComponents.at(i)->getBounds();
posX = ev.x;
if((int)_regionComponents.at(i)->getPositionX() < posX && posX < ((int)_regionComponents.at(i)->getPositionX() + (int)_regionComponents.at(i)->getRegionWidth()))
{
_track->remove(_regionComponents.at(i)->getRegion(), _posX.at(i));
std::vector<RegionComponent*>::iterator regit = _regionComponents.begin() + i;
RegionComponent* component = _regionComponents.at(i);
removeChildComponent(_regionComponents.at(i));
_regionComponents.erase(regit);
delete component;
_regions.erase(_posX.at(i));
std::vector<int64>::iterator posit = _posX.begin() + i;;
_posX.erase(posit);
std::vector<int64>::iterator sampsit = _sizeSamps.begin() + i;;
_sizeSamps.erase(sampsit);
}
}
critical.exit();
}
default:
break;
}
}
}
// for playing a valid audio file given by the slot
// if this function is called by a slot for the first time, audio will be played
// if a slot called this function twice in sequence, the currently played
// audio will be stopped
void Player::play(Slot *givenSlot) {
QString filepath = givenSlot->getPath();
QFile audioFile(filepath);
// in order to stop playback for the audio file given by the
// same slot after calling this function in sequence DURING playback
if(givenSlot == lastSlot)
stop();
else {
stop();
lastSlot = givenSlot;
// some basic checks:
// 1. check audio file (*.wav ending AND subsistence)
if(!filepath.endsWith(".wav", Qt::CaseInsensitive)) {
// if the given file is not valid, you don't have to call this
// function twice in order to play a (new set) valid file
if(lastSlot != NULL)
lastSlot = NULL;
throw QString("The given audio file is no *.wav!");
}
if(!audioFile.exists())
throw QString("The given audio file does not exist!");
// 2. check if format is supported by the audio device
if(!device.isFormatSupported(format))
throw QString("Raw audio format not supported by back-end, cannot play audio.");
// if audio is currently playing - stop it
stop();
// prepare audio playback
player = new QAudioOutput(device, format);
player->setNotifyInterval(500);
connect(player, SIGNAL(stateChanged(QAudio::State)), this, SLOT(handleStateChanged(QAudio::State)));
//connect(player, SIGNAL(notify()), this, SLOT(displayCurrentDuration()));
// read audio data
if(audioFile.open(QIODevice::ReadOnly)) {
// read out wav info
// ######### IMPLEMENTATION #########
audioFile.seek(44); // skip wav header
audioData = audioFile.readAll();
audioFile.close();
audioBuffer.setBuffer(&audioData);
audioBuffer.open(QIODevice::ReadOnly); // prepare/open buffer for playback
lastSlot->setStatus(SlotStatus::PLAYING);
// start playback thread
player->start(&audioBuffer);
qDebug() << ">> Audio has been started.";
}
}
}
bool AudioSourceFilePrelistener::play(const String& absolutePathToAudioFile,
const int& startPosition_,
const int& endPosition_)
{
DEB("AudioSourceFilePreview::play called.");
// If a new audio file is specified,
// delete the old bufferingAudioSource and
// create a new bufferingAudioSource
if (absolutePathToAudioFile != previouslyUsedPathToAudioFile)
{
// delete the old audioFormatReaderSource
// (exept the first time, when there is no audioFormatReaderSource)
if (bufferingAudioSource != NULL)
{
bufferingAudioSource->releaseResources();
delete bufferingAudioSource;
}
// \/ \/ \/ Similar to AudioRegionMixer::addRegion \/ \/ \/
// --- begin{audio file stuff} ---
File audioFile(absolutePathToAudioFile);
// get a format manager and set it up with the basic types (wav and aiff).
AudioFormatManager audioFormatManager;
audioFormatManager.registerBasicFormats();
// Currently, this registers the WAV and AIFF formats.
AudioFormatReader* audioFormatReader = audioFormatManager.createReaderFor (audioFile);
// This audioFormatReader will be deleted when the audioFormatReaderSource will
// be deleted
// --- end{audio file stuff} ---
// if the previous lines of code weren't successful
if (audioFormatReader == NULL)
{
DEB("AudioSourceFilePrelistener: The audio file couldn't be read.")
delete audioFormatReader;
bufferingAudioSource = NULL;
runPlayback = false;
return false;
}
// Check if this input set is invalid
if (startPosition_ >= endPosition_
|| startPosition_ < 0
|| endPosition_ > audioFormatReader->lengthInSamples)
{
DEB("AudioSourceFilePrelistener: Didn't play because the given"
"startPosition (" + String(startPosition_) + ") and endPosition ("
+ String(endPosition_) + ") don't make sense.")
delete audioFormatReader;
bufferingAudioSource = NULL;
runPlayback = false;
return false;
}
// /\ /\ /\ End of similar to AudioRegionMixer::addRegion /\ /\ /\
const bool deleteAudioFormatReaderWhenDeleted = true;
AudioFormatReaderSource* audioFormatReaderSource = new AudioFormatReaderSource (audioFormatReader, deleteAudioFormatReaderWhenDeleted);
bool deleteSourceWhenDeleted = true;
bufferingAudioSource = new BufferingAudioSource (audioFormatReaderSource, deleteSourceWhenDeleted, 32768);
bufferingAudioSource->prepareToPlay(samplesPerBlockExpected, sampleRate);
}
else
// if (absolutePathToAudioFile == previouslyUsedPathToAudioFile)
{
// Check if this input set is invalid
if (startPosition_ >= endPosition
|| startPosition_ < 0
|| endPosition_ > bufferingAudioSource->getTotalLength())
{
DEB("AudioSourceFilePrelistener: Didn't play because the given"
"startPosition (" + String(startPosition_) + ") and endPosition ("
+ String(endPosition_) + ") don't make sense.")
runPlayback = false;
return false;
}
}
nextPlayPosition = startPosition_;
endPosition = endPosition_;
bufferingAudioSource->setNextReadPosition (nextPlayPosition);
runPlayback = true;
return true;
}
const AudioFileModel AnalyzeTask::analyzeFile(const QString &filePath, int *type)
{
*type = fileTypeNormal;
AudioFileModel audioFile(filePath);
QFile readTest(filePath);
if(!readTest.open(QIODevice::ReadOnly))
{
*type = fileTypeDenied;
return audioFile;
}
if(checkFile_CDDA(readTest))
{
*type = fileTypeCDDA;
return audioFile;
}
readTest.close();
bool skipNext = false;
QPair<quint32, quint32> id_val(UINT_MAX, UINT_MAX);
quint32 coverType = UINT_MAX;
QByteArray coverData;
QStringList params;
params << QString("--Inform=file://%1").arg(QDir::toNativeSeparators(m_templateFile));
params << QDir::toNativeSeparators(filePath);
QProcess process;
MUtils::init_process(process, QFileInfo(m_mediaInfoBin).absolutePath());
process.start(m_mediaInfoBin, params);
if(!process.waitForStarted())
{
qWarning("MediaInfo process failed to create!");
qWarning("Error message: \"%s\"\n", process.errorString().toLatin1().constData());
process.kill();
process.waitForFinished(-1);
return audioFile;
}
while(process.state() != QProcess::NotRunning)
{
if(*m_abortFlag)
{
process.kill();
qWarning("Process was aborted on user request!");
break;
}
if(!process.waitForReadyRead())
{
if(process.state() == QProcess::Running)
{
qWarning("MediaInfo time out. Killing process and skipping file!");
process.kill();
process.waitForFinished(-1);
return audioFile;
}
}
QByteArray data;
while(process.canReadLine())
{
QString line = QString::fromUtf8(process.readLine().constData()).simplified();
if(!line.isEmpty())
{
//qDebug("Line:%s", MUTILS_UTF8(line));
int index = line.indexOf('=');
if(index > 0)
{
QString key = line.left(index).trimmed();
QString val = line.mid(index+1).trimmed();
if(!key.isEmpty())
{
updateInfo(audioFile, skipNext, id_val, coverType, coverData, key, val);
}
}
}
}
}
if(audioFile.metaInfo().title().isEmpty())
{
QString baseName = QFileInfo(filePath).fileName();
int index = baseName.lastIndexOf(".");
if(index >= 0)
{
baseName = baseName.left(index);
}
baseName = baseName.replace("_", " ").simplified();
index = baseName.lastIndexOf(" - ");
if(index >= 0)
{
baseName = baseName.mid(index + 3).trimmed();
}
audioFile.metaInfo().setTitle(baseName);
}
process.waitForFinished();
if(process.state() != QProcess::NotRunning)
{
process.kill();
process.waitForFinished(-1);
}
if((coverType != UINT_MAX) && (!coverData.isEmpty()))
{
retrieveCover(audioFile, coverType, coverData);
}
if((audioFile.techInfo().audioType().compare("PCM", Qt::CaseInsensitive) == 0) && (audioFile.techInfo().audioProfile().compare("Float", Qt::CaseInsensitive) == 0))
{
if(audioFile.techInfo().audioBitdepth() == 32) audioFile.techInfo().setAudioBitdepth(AudioFileModel::BITDEPTH_IEEE_FLOAT32);
}
return audioFile;
}
