musicdsp/audio-ess
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] set it basic work again with RIVER

Browse Source
This commit is contained in:
Edouard DUPIN 2015-02-13 21:06:55 +01:00
parent af355c4051
commit 23467923b4
9 changed files with 88 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
ewolsa/LoadedFile.cpp
View File

@ -13,30 +13,31 @@
#include <ewolsa/decWav.h> #include <ewolsa/decWav.h>
#include <ewolsa/decOgg.h> #include <ewolsa/decOgg.h>
static void* threadCallback2(void *_ptr) { static void threadCallback2(void* _userData) {
ewolsa::LoadedFile* decodeFile = (ewolsa::LoadedFile*)_ptr; etk::log::setThreadName("ewolSA decoder");
ewolsa::LoadedFile* decodeFile = reinterpret_cast<ewolsa::LoadedFile*>(_userData);
decodeFile->decode(); decodeFile->decode();
return NULL;
} }
void ewolsa::LoadedFile::decode() { void ewolsa::LoadedFile::decode() {
m_data = ewolsa::ogg::loadAudioFile(m_file, m_nbChanRequested, m_nbSamples); m_data = ewolsa::ogg::loadAudioFile(m_file, m_nbChanRequested);
m_nbSamples = m_data.size();
} }
ewolsa::LoadedFile::LoadedFile(const std::string& _fileName, int8_t _nbChanRequested) : ewolsa::LoadedFile::LoadedFile(const std::string& _fileName, int8_t _nbChanRequested) :
m_thread(nullptr),
m_file(_fileName), m_file(_fileName),
m_nbSamples(0), m_nbSamples(0),
m_nbChanRequested(_nbChanRequested), m_nbChanRequested(_nbChanRequested),
m_requestedTime(1), m_requestedTime(1){
m_data(NULL){
m_thread = NULL;
std::string tmpName = etk::tolower(m_file); std::string tmpName = etk::tolower(m_file);
// select the corect Loader : // select the corect Loader :
if (etk::end_with(tmpName, ".wav") == true) { if (etk::end_with(tmpName, ".wav") == true) {
m_data = ewolsa::wav::loadAudioFile(m_file, m_nbChanRequested, m_nbSamples); m_data = ewolsa::wav::loadAudioFile(m_file, m_nbChanRequested);
m_nbSamples = m_data.size();
} else if (etk::end_with(tmpName, ".ogg") == true) { } else if (etk::end_with(tmpName, ".ogg") == true) {
EWOLSA_DEBUG("create thread"); EWOLSA_DEBUG("create thread");
pthread_create(&m_thread2, NULL, &threadCallback2, this); m_thread = new std::thread(&threadCallback2, this);
EWOLSA_DEBUG("done 1"); EWOLSA_DEBUG("done 1");
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); std::this_thread::sleep_for(std::chrono::milliseconds(1000));
EWOLSA_DEBUG("done 2"); EWOLSA_DEBUG("done 2");
@ -45,7 +46,7 @@ ewolsa::LoadedFile::LoadedFile(const std::string& _fileName, int8_t _nbChanReque
return; return;
} }
/* /*
if (m_data == NULL) { if (m_data == nullptr) {
// write an error ... // write an error ...
EWOLSA_ERROR("Can not open file : " << _fileName); EWOLSA_ERROR("Can not open file : " << _fileName);
} }
@ -54,10 +55,8 @@ ewolsa::LoadedFile::LoadedFile(const std::string& _fileName, int8_t _nbChanReque
ewolsa::LoadedFile::~LoadedFile() { ewolsa::LoadedFile::~LoadedFile() {
// TODO : wait end of thread... if (m_thread != nullptr) {
if (m_data != NULL) { delete m_thread;
delete[] m_data;
m_data = NULL;
} }
} }

3
ewolsa/LoadedFile.h
View File

@ -18,7 +18,6 @@ namespace ewolsa {
class LoadedFile { class LoadedFile {
private: private:
std::thread* m_thread; std::thread* m_thread;
pthread_t m_thread2;
public: public:
LoadedFile(const std::string& _fileName, int8_t _nbChanRequested=1); LoadedFile(const std::string& _fileName, int8_t _nbChanRequested=1);
~LoadedFile(); ~LoadedFile();
@ -26,7 +25,7 @@ namespace ewolsa {
int32_t m_nbSamples; int32_t m_nbSamples;
int32_t m_nbChanRequested; int32_t m_nbChanRequested;
int32_t m_requestedTime; int32_t m_requestedTime;
int16_t* m_data; std::vector<int16_t> m_data;
public: public:
const std::string& getName() { const std::string& getName() {
return m_file; return m_file;

26
ewolsa/decOgg.cpp
View File

@ -48,8 +48,7 @@ static long localTellFunc(void *datasource) {
return file->fileTell(); return file->fileTell();
} }
int16_t* ewolsa::ogg::loadAudioFile(const std::string& _filename, int8_t _nbChan, int32_t& _nbSampleOut) { std::vector<int16_t> ewolsa::ogg::loadAudioFile(const std::string& _filename, int8_t _nbChan) {
_nbSampleOut = 0;
OggVorbis_File vf; OggVorbis_File vf;
int32_t eof=0; int32_t eof=0;
int32_t current_section; int32_t current_section;
@ -64,23 +63,23 @@ int16_t* ewolsa::ogg::loadAudioFile(const std::string& _filename, int8_t _nbChan
//EWOLSA_DEBUG("open file (OGG) \"" << fileAccess << "\""); //EWOLSA_DEBUG("open file (OGG) \"" << fileAccess << "\"");
if (false == fileAccess->exist()) { if (false == fileAccess->exist()) {
//EWOLSA_ERROR("File Does not exist : \"" << fileAccess << "\""); //EWOLSA_ERROR("File Does not exist : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
int32_t fileSize = fileAccess->fileSize(); int32_t fileSize = fileAccess->fileSize();
if (0 == fileSize) { if (0 == fileSize) {
//EWOLSA_ERROR("This file is empty : \"" << fileAccess << "\""); //EWOLSA_ERROR("This file is empty : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
if (false == fileAccess->fileOpenRead()) { if (false == fileAccess->fileOpenRead()) {
//EWOLSA_ERROR("Can not open the file : \"" << fileAccess << "\""); //EWOLSA_ERROR("Can not open the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
if (ov_open_callbacks(&(*fileAccess), &vf, NULL, 0, tmpCallback) < 0) { if (ov_open_callbacks(&(*fileAccess), &vf, nullptr, 0, tmpCallback) < 0) {
//EWOLSA_ERROR("Input does not appear to be an Ogg bitstream."); //EWOLSA_ERROR("Input does not appear to be an Ogg bitstream.");
return NULL; return std::vector<int16_t>();
} }
vorbis_info *vi=ov_info(&vf,-1); vorbis_info *vi=ov_info(&vf,-1);
_nbSampleOut = ov_pcm_total(&vf,-1) / vi->channels; int32_t nbSampleOut = ov_pcm_total(&vf,-1) / vi->channels;
/* /*
{ {
char **ptr=ov_comment(&vf,-1)->user_comments; char **ptr=ov_comment(&vf,-1)->user_comments;
@ -94,11 +93,8 @@ int16_t* ewolsa::ogg::loadAudioFile(const std::string& _filename, int8_t _nbChan
EWOLSA_DEBUG("time: " << ((float)_nbSampleOut/(float)vi->rate)/60.0); EWOLSA_DEBUG("time: " << ((float)_nbSampleOut/(float)vi->rate)/60.0);
} }
*/ */
int16_t* outputData = new int16_t[_nbSampleOut*_nbChan*sizeof(int16_t)]; std::vector<int16_t> outputData;
if (NULL == outputData) { outputData.resize(nbSampleOut*_nbChan, 0);
//EWOLSA_ERROR("Allocation ERROR try to allocate " << (int32_t)(_nbSampleOut*_nbChan*sizeof(int16_t) ) << "bytes");
return NULL;
}
int32_t pos = 0; int32_t pos = 0;
char pcmout[4096]; char pcmout[4096];
while(!eof){ while(!eof){
@ -110,11 +106,11 @@ int16_t* ewolsa::ogg::loadAudioFile(const std::string& _filename, int8_t _nbChan
if(ret==OV_EBADLINK){ if(ret==OV_EBADLINK){
//EWOLSA_ERROR("Corrupt bitstream section! Exiting."); //EWOLSA_ERROR("Corrupt bitstream section! Exiting.");
// TODO : Remove pointer data ... // TODO : Remove pointer data ...
return NULL; return std::vector<int16_t>();
} }
} else { } else {
int16_t* pointerIn = (int16_t*)pcmout; int16_t* pointerIn = (int16_t*)pcmout;
int16_t* pointerOut = outputData+pos; int16_t* pointerOut = &outputData[0]+pos;
if (_nbChan == vi->channels) { if (_nbChan == vi->channels) {
memcpy(pointerOut, pointerIn, ret); memcpy(pointerOut, pointerIn, ret);
pos += ret/2; pos += ret/2;

2
ewolsa/decOgg.h
View File

@ -13,7 +13,7 @@
namespace ewolsa { namespace ewolsa {
namespace ogg { namespace ogg {
int16_t* loadAudioFile(const std::string& _filename, int8_t _nbChan, int32_t& _nbSampleOut); std::vector<int16_t> loadAudioFile(const std::string& _filename, int8_t _nbChan);
} }
}; };

67
ewolsa/decWav.cpp
View File

@ -59,8 +59,7 @@ typedef struct {
#define COMPR_G721 (64) #define COMPR_G721 (64)
#define COMPR_MPEG (80) #define COMPR_MPEG (80)
int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan, int32_t& _nbSampleOut) { std::vector<int16_t> ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan) {
_nbSampleOut = 0;
waveHeader myHeader; waveHeader myHeader;
memset(&myHeader, 0, sizeof(waveHeader)); memset(&myHeader, 0, sizeof(waveHeader));
etk::FSNode fileAccess(_filename); etk::FSNode fileAccess(_filename);
@ -69,28 +68,28 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
if (false == fileAccess.exist()) { if (false == fileAccess.exist()) {
EWOLSA_ERROR("File Does not exist : \"" << fileAccess << "\""); EWOLSA_ERROR("File Does not exist : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
int32_t fileSize = fileAccess.fileSize(); int32_t fileSize = fileAccess.fileSize();
if (0 == fileSize) { if (0 == fileSize) {
EWOLSA_ERROR("This file is empty : \"" << fileAccess << "\""); EWOLSA_ERROR("This file is empty : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
if (false == fileAccess.fileOpenRead()) { if (false == fileAccess.fileOpenRead()) {
EWOLSA_ERROR("Can not open the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not open the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
// try to find endienness : // try to find endienness :
if (fileSize < (int64_t)sizeof(waveHeader)) { if (fileSize < (int64_t)sizeof(waveHeader)) {
EWOLSA_ERROR("File : \"" << fileAccess << "\" == > has not enouth data inside might be minumum of " << (int32_t)(sizeof(waveHeader))); EWOLSA_ERROR("File : \"" << fileAccess << "\" == > has not enouth data inside might be minumum of " << (int32_t)(sizeof(waveHeader)));
return NULL; return std::vector<int16_t>();
} }
// ---------------------------------------------- // ----------------------------------------------
// read the header : // read the header :
// ---------------------------------------------- // ----------------------------------------------
if (fileAccess.fileRead(&myHeader.riffTag, 1, 4)!=4) { if (fileAccess.fileRead(&myHeader.riffTag, 1, 4)!=4) {
EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
bool littleEndien = false; bool littleEndien = false;
if( myHeader.riffTag[0] == 'R' if( myHeader.riffTag[0] == 'R'
@ -102,55 +101,55 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
} }
} else { } else {
EWOLSA_ERROR("file: \"" << fileAccess << "\" Does not start with \"RIF\" " ); EWOLSA_ERROR("file: \"" << fileAccess << "\" Does not start with \"RIF\" " );
return NULL; return std::vector<int16_t>();
} }
// get the data size : // get the data size :
unsigned char tmpData[32]; unsigned char tmpData[32];
if (fileAccess.fileRead(tmpData, 1, 4)!=4) { if (fileAccess.fileRead(tmpData, 1, 4)!=4) {
EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
myHeader.size = CONVERT_UINT32(littleEndien, tmpData); myHeader.size = CONVERT_UINT32(littleEndien, tmpData);
// get the data size : // get the data size :
if (fileAccess.fileRead(&myHeader.waveTag, 1, 4)!=4) { if (fileAccess.fileRead(&myHeader.waveTag, 1, 4)!=4) {
EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
if( myHeader.waveTag[0] != 'W' if( myHeader.waveTag[0] != 'W'
|| myHeader.waveTag[1] != 'A' || myHeader.waveTag[1] != 'A'
|| myHeader.waveTag[2] != 'V' || myHeader.waveTag[2] != 'V'
|| myHeader.waveTag[3] != 'E' ) { || myHeader.waveTag[3] != 'E' ) {
EWOLSA_ERROR("file: \"" << fileAccess << "\" This is not a wave file " << myHeader.waveTag[0] << myHeader.waveTag[1] << myHeader.waveTag[2] << myHeader.waveTag[3] ); EWOLSA_ERROR("file: \"" << fileAccess << "\" This is not a wave file " << myHeader.waveTag[0] << myHeader.waveTag[1] << myHeader.waveTag[2] << myHeader.waveTag[3] );
return NULL; return std::vector<int16_t>();
} }
// get the data size : // get the data size :
if (fileAccess.fileRead(&myHeader.fmtTag, 1, 4)!=4) { if (fileAccess.fileRead(&myHeader.fmtTag, 1, 4)!=4) {
EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
if( myHeader.fmtTag[0] != 'f' if( myHeader.fmtTag[0] != 'f'
|| myHeader.fmtTag[1] != 'm' || myHeader.fmtTag[1] != 'm'
|| myHeader.fmtTag[2] != 't' || myHeader.fmtTag[2] != 't'
|| myHeader.fmtTag[3] != ' ' ) { || myHeader.fmtTag[3] != ' ' ) {
EWOLSA_ERROR("file: \"" << fileAccess << "\" header error ..." << myHeader.fmtTag[0] << myHeader.fmtTag[1] << myHeader.fmtTag[2] << myHeader.fmtTag[3]); EWOLSA_ERROR("file: \"" << fileAccess << "\" header error ..." << myHeader.fmtTag[0] << myHeader.fmtTag[1] << myHeader.fmtTag[2] << myHeader.fmtTag[3]);
return NULL; return std::vector<int16_t>();
} }
// get the data size : // get the data size :
if (fileAccess.fileRead(tmpData, 1, 4)!=4) { if (fileAccess.fileRead(tmpData, 1, 4)!=4) {
EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
myHeader.waveFormatSize = CONVERT_UINT32(littleEndien, tmpData); myHeader.waveFormatSize = CONVERT_UINT32(littleEndien, tmpData);
if (myHeader.waveFormatSize != 16) { if (myHeader.waveFormatSize != 16) {
EWOLSA_ERROR("file : \"" << fileAccess << "\" == > header error ..."); EWOLSA_ERROR("file : \"" << fileAccess << "\" == > header error ...");
return NULL; return std::vector<int16_t>();
} }
if (fileAccess.fileRead(tmpData, 1, 16)!=16) { if (fileAccess.fileRead(tmpData, 1, 16)!=16) {
EWOLSA_ERROR("Can not 16 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 16 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
unsigned char * tmppp = tmpData; unsigned char * tmppp = tmpData;
myHeader.waveFormat.type = CONVERT_UINT16(littleEndien, tmppp); myHeader.waveFormat.type = CONVERT_UINT16(littleEndien, tmppp);
@ -174,19 +173,19 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
// get the data size : // get the data size :
if (fileAccess.fileRead(&myHeader.dataTag, 1, 4)!=4) { if (fileAccess.fileRead(&myHeader.dataTag, 1, 4)!=4) {
EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
if( myHeader.dataTag[0] != 'd' if( myHeader.dataTag[0] != 'd'
|| myHeader.dataTag[1] != 'a' || myHeader.dataTag[1] != 'a'
|| myHeader.dataTag[2] != 't' || myHeader.dataTag[2] != 't'
|| myHeader.dataTag[3] != 'a' ) { || myHeader.dataTag[3] != 'a' ) {
EWOLSA_ERROR("file: \"" << fileAccess << "\" header error ..." << myHeader.dataTag[0] << myHeader.dataTag[1] << myHeader.dataTag[2] << myHeader.dataTag[3]); EWOLSA_ERROR("file: \"" << fileAccess << "\" header error ..." << myHeader.dataTag[0] << myHeader.dataTag[1] << myHeader.dataTag[2] << myHeader.dataTag[3]);
return NULL; return std::vector<int16_t>();
} }
// get the data size : // get the data size :
if (fileAccess.fileRead(tmpData, 1, 4)!=4) { if (fileAccess.fileRead(tmpData, 1, 4)!=4) {
EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\""); EWOLSA_ERROR("Can not 4 element in the file : \"" << fileAccess << "\"");
return NULL; return std::vector<int16_t>();
} }
myHeader.dataSize = CONVERT_UINT32(littleEndien, tmpData); myHeader.dataSize = CONVERT_UINT32(littleEndien, tmpData);
@ -197,33 +196,30 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
//Parse the data and transform it if needed ... //Parse the data and transform it if needed ...
if (COMPR_PCM != myHeader.waveFormat.type) { if (COMPR_PCM != myHeader.waveFormat.type) {
EWOLSA_ERROR("File : \"" << fileAccess << "\" == > support only PCM compression ..."); EWOLSA_ERROR("File : \"" << fileAccess << "\" == > support only PCM compression ...");
return NULL; return std::vector<int16_t>();
} }
if (myHeader.waveFormat.channelCount == 0 || myHeader.waveFormat.channelCount>2) { if (myHeader.waveFormat.channelCount == 0 || myHeader.waveFormat.channelCount>2) {
EWOLSA_ERROR("File : \"" << fileAccess << "\" == > support only mono or stereo ..." << myHeader.waveFormat.channelCount); EWOLSA_ERROR("File : \"" << fileAccess << "\" == > support only mono or stereo ..." << myHeader.waveFormat.channelCount);
return NULL; return std::vector<int16_t>();
} }
if ( ! ( myHeader.waveFormat.bitsPerSample == 16 if ( ! ( myHeader.waveFormat.bitsPerSample == 16
|| myHeader.waveFormat.bitsPerSample == 24 || myHeader.waveFormat.bitsPerSample == 24
|| myHeader.waveFormat.bitsPerSample == 32 ) ) { || myHeader.waveFormat.bitsPerSample == 32 ) ) {
EWOLSA_ERROR("File : \"" << fileAccess << "\" == > not supported bit/sample ..." << myHeader.waveFormat.bitsPerSample); EWOLSA_ERROR("File : \"" << fileAccess << "\" == > not supported bit/sample ..." << myHeader.waveFormat.bitsPerSample);
return NULL; return std::vector<int16_t>();
} }
if( ! ( 44100 == myHeader.waveFormat.samplesPerSec if( ! ( 44100 == myHeader.waveFormat.samplesPerSec
|| 48000 == myHeader.waveFormat.samplesPerSec) ) { || 48000 == myHeader.waveFormat.samplesPerSec) ) {
EWOLSA_ERROR("File : \"" << fileAccess << "\" == > not supported frequency " << myHeader.waveFormat.samplesPerSec << " != 48000"); EWOLSA_ERROR("File : \"" << fileAccess << "\" == > not supported frequency " << myHeader.waveFormat.samplesPerSec << " != 48000");
return NULL; return std::vector<int16_t>();
} }
EWOLSA_DEBUG(" dataSize : " << myHeader.dataSize); EWOLSA_DEBUG(" dataSize : " << myHeader.dataSize);
//int32_t globalDataSize = myHeader.dataSize; //int32_t globalDataSize = myHeader.dataSize;
int32_t nbSample = (myHeader.dataSize/((myHeader.waveFormat.bitsPerSample/8)*myHeader.waveFormat.channelCount)); int32_t nbSample = (myHeader.dataSize/((myHeader.waveFormat.bitsPerSample/8)*myHeader.waveFormat.channelCount));
int32_t outputSize = _nbChan*nbSample; int32_t outputSize = _nbChan*nbSample;
int16_t * outputData = new int16_t[outputSize*sizeof(int16_t)]; std::vector<int16_t> outputData;
if (NULL == outputData) { outputData.resize(outputSize, 0);
EWOLSA_ERROR("Allocation ERROR try to allocate " << (int32_t)(outputSize*sizeof(int16_t) ) << "bytes"); int16_t * tmpOut = &outputData[0];
return NULL;
}
int16_t * tmpOut = outputData;
for( int32_t iii=0; iii<nbSample; iii++) { for( int32_t iii=0; iii<nbSample; iii++) {
int32_t left; int32_t left;
int32_t right; int32_t right;
@ -232,14 +228,14 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
if (myHeader.waveFormat.channelCount == 1) { if (myHeader.waveFormat.channelCount == 1) {
if (fileAccess.fileRead(audioSample, 1, 2)!=2) { if (fileAccess.fileRead(audioSample, 1, 2)!=2) {
EWOLSA_ERROR("Read Error at position : " << iii); EWOLSA_ERROR("Read Error at position : " << iii);
return NULL; return std::vector<int16_t>();
} }
left = ((int32_t)((int16_t)CONVERT_INT16(littleEndien, audioSample))) << 16; left = ((int32_t)((int16_t)CONVERT_INT16(littleEndien, audioSample))) << 16;
right = left; right = left;
} else { } else {
if (fileAccess.fileRead(audioSample, 1, 4)!=4) { if (fileAccess.fileRead(audioSample, 1, 4)!=4) {
EWOLSA_ERROR("Read Error at position : " << iii); EWOLSA_ERROR("Read Error at position : " << iii);
return NULL; return std::vector<int16_t>();
} }
left = (int32_t)((int16_t)CONVERT_INT16(littleEndien, audioSample)) << 16; left = (int32_t)((int16_t)CONVERT_INT16(littleEndien, audioSample)) << 16;
right = (int32_t)((int16_t)CONVERT_INT16(littleEndien, audioSample+2)) << 16; right = (int32_t)((int16_t)CONVERT_INT16(littleEndien, audioSample+2)) << 16;
@ -248,14 +244,14 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
if (myHeader.waveFormat.channelCount == 1) { if (myHeader.waveFormat.channelCount == 1) {
if (fileAccess.fileRead(audioSample, 1, 3)!=3) { if (fileAccess.fileRead(audioSample, 1, 3)!=3) {
EWOLSA_ERROR("Read Error at position : " << iii); EWOLSA_ERROR("Read Error at position : " << iii);
return NULL; return std::vector<int16_t>();
} }
left = CONVERT_INT24(littleEndien, audioSample); left = CONVERT_INT24(littleEndien, audioSample);
right = left; right = left;
} else { } else {
if (fileAccess.fileRead(audioSample, 1, 6)!=6) { if (fileAccess.fileRead(audioSample, 1, 6)!=6) {
EWOLSA_ERROR("Read Error at position : " << iii); EWOLSA_ERROR("Read Error at position : " << iii);
return NULL; return std::vector<int16_t>();
} }
left = CONVERT_INT24(littleEndien, audioSample); left = CONVERT_INT24(littleEndien, audioSample);
right = CONVERT_INT24(littleEndien, audioSample+3); right = CONVERT_INT24(littleEndien, audioSample+3);
@ -264,14 +260,14 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
if (myHeader.waveFormat.channelCount == 1) { if (myHeader.waveFormat.channelCount == 1) {
if (fileAccess.fileRead(audioSample, 1, 4)!=4) { if (fileAccess.fileRead(audioSample, 1, 4)!=4) {
EWOLSA_ERROR("Read Error at position : " << iii); EWOLSA_ERROR("Read Error at position : " << iii);
return NULL; return std::vector<int16_t>();
} }
left = CONVERT_INT32(littleEndien, audioSample); left = CONVERT_INT32(littleEndien, audioSample);
right = left; right = left;
} else { } else {
if (fileAccess.fileRead(audioSample, 1, 8)!=8) { if (fileAccess.fileRead(audioSample, 1, 8)!=8) {
EWOLSA_ERROR("Read Error at position : " << iii); EWOLSA_ERROR("Read Error at position : " << iii);
return NULL; return std::vector<int16_t>();
} }
left = CONVERT_INT32(littleEndien, audioSample); left = CONVERT_INT32(littleEndien, audioSample);
right = CONVERT_INT32(littleEndien, audioSample+4); right = CONVERT_INT32(littleEndien, audioSample+4);
@ -286,7 +282,6 @@ int16_t* ewolsa::wav::loadAudioFile(const std::string& _filename, int8_t _nbChan
} }
// close the file: // close the file:
fileAccess.fileClose(); fileAccess.fileClose();
_nbSampleOut = nbSample;
return outputData; return outputData;
} }

2
ewolsa/decWav.h
View File

@ -13,7 +13,7 @@
namespace ewolsa { namespace ewolsa {
namespace wav { namespace wav {
int16_t* loadAudioFile(const std::string& _filename, int8_t _nbChan, int32_t& _nbSampleOut); std::vector<int16_t> loadAudioFile(const std::string& _filename, int8_t _nbChan);
} }
}; };

14
ewolsa/effects.cpp
View File

@ -50,7 +50,7 @@ class RequestPlay {
if (true == m_freeSlot) { if (true == m_freeSlot) {
return; return;
} }
if (m_effect->m_data == NULL) { if (m_effect->m_data.size() == 0) {
m_freeSlot = true; m_freeSlot = true;
return; return;
} }
@ -93,7 +93,7 @@ void ewolsa::effects::unInit() {
int32_t ewolsa::effects::add(const std::string& _file) { int32_t ewolsa::effects::add(const std::string& _file) {
for (size_t iii=0; iii<ListEffects.size(); iii++) { for (size_t iii=0; iii<ListEffects.size(); iii++) {
if (ListEffects[iii] == NULL) { if (ListEffects[iii] == nullptr) {
continue; continue;
} }
if (ListEffects[iii]->m_file == _file) { if (ListEffects[iii]->m_file == _file) {
@ -103,7 +103,7 @@ int32_t ewolsa::effects::add(const std::string& _file) {
} }
// effect does not exist ... create a new one ... // effect does not exist ... create a new one ...
ewolsa::LoadedFile * tmpEffect = new ewolsa::LoadedFile(_file); ewolsa::LoadedFile * tmpEffect = new ewolsa::LoadedFile(_file);
if (NULL == tmpEffect) { if (nullptr == tmpEffect) {
EWOLSA_ERROR("Error to load the effects : \"" << _file << "\""); EWOLSA_ERROR("Error to load the effects : \"" << _file << "\"");
return -1; return -1;
} }
@ -117,7 +117,7 @@ void ewolsa::effects::rm(int32_t _effectId) {
EWOLSA_ERROR("Wrong effect ID : " << _effectId << " != [0.." << ListEffects.size()-1 << "] == > can not remove it ..."); EWOLSA_ERROR("Wrong effect ID : " << _effectId << " != [0.." << ListEffects.size()-1 << "] == > can not remove it ...");
return; return;
} }
if (ListEffects[_effectId] == NULL) { if (ListEffects[_effectId] == nullptr) {
EWOLSA_ERROR("effect ID : " << _effectId << " == > has already been removed"); EWOLSA_ERROR("effect ID : " << _effectId << " == > has already been removed");
return; return;
} }
@ -137,7 +137,7 @@ void ewolsa::effects::play(int32_t _effectId, float _xxx, float _yyy) {
EWOLSA_ERROR("Wrong effect ID : " << _effectId << " != [0.." << ListEffects.size()-1 << "] == > can not play it ..."); EWOLSA_ERROR("Wrong effect ID : " << _effectId << " != [0.." << ListEffects.size()-1 << "] == > can not play it ...");
return; return;
} }
if (ListEffects[_effectId] == NULL) { if (ListEffects[_effectId] == nullptr) {
EWOLSA_ERROR("effect ID : " << _effectId << " == > has been removed"); EWOLSA_ERROR("effect ID : " << _effectId << " == > has been removed");
return; return;
} }
@ -150,7 +150,7 @@ void ewolsa::effects::play(int32_t _effectId, float _xxx, float _yyy) {
} }
} }
RequestPlay* newPlay = new RequestPlay(ListEffects[_effectId]); RequestPlay* newPlay = new RequestPlay(ListEffects[_effectId]);
if (NULL == newPlay) { if (nullptr == newPlay) {
EWOLSA_CRITICAL("Allocation error of a playing element : " << _effectId); EWOLSA_CRITICAL("Allocation error of a playing element : " << _effectId);
return; return;
} }
@ -197,7 +197,7 @@ void ewolsa::effects::muteSet(bool _newMute) {
void ewolsa::effects::getData(int16_t* _bufferInterlace, int32_t _nbSample, int32_t _nbChannels) { void ewolsa::effects::getData(int16_t* _bufferInterlace, int32_t _nbSample, int32_t _nbChannels) {
for (size_t iii = 0; iii < ListEffectsPlaying.size(); ++iii) { for (size_t iii = 0; iii < ListEffectsPlaying.size(); ++iii) {
if (ListEffectsPlaying[iii]!= NULL) { if (ListEffectsPlaying[iii]!= nullptr) {
ListEffectsPlaying[iii]->play(_bufferInterlace, _nbSample, _nbChannels); ListEffectsPlaying[iii]->play(_bufferInterlace, _nbSample, _nbChannels);
} }
} }

9
ewolsa/ewolsa.cpp
View File

@ -31,6 +31,10 @@ class OutputInterface {
audio::format_int16, audio::format_int16,
"speaker", "speaker",
"ewolsa::basicOutput"); "ewolsa::basicOutput");
if (m_interface == nullptr) {
EWOLSA_ERROR("can not allocate output interface ... ");
return;
}
// set callback mode ... // set callback mode ...
m_interface->setOutputCallback(1024, m_interface->setOutputCallback(1024,
std::bind(&OutputInterface::onDataNeeded, std::bind(&OutputInterface::onDataNeeded,
@ -43,6 +47,9 @@ class OutputInterface {
m_interface->start(); m_interface->start();
} }
~OutputInterface() { ~OutputInterface() {
if (m_interface == nullptr) {
return;
}
m_interface->stop(); m_interface->stop();
m_interface.reset(); m_interface.reset();
m_manager.reset(); m_manager.reset();
@ -58,7 +65,7 @@ class OutputInterface {
// call music // call music
ewolsa::music::getData(static_cast<int16_t*>(_data), _nbChunk, _map.size()); ewolsa::music::getData(static_cast<int16_t*>(_data), _nbChunk, _map.size());
// call Effects // call Effects
ewolsa::effects::getData(static_cast<int16_t*>(_data), _nbChunk, _map.size()); //ewolsa::effects::getData(static_cast<int16_t*>(_data), _nbChunk, _map.size());
} }
}; };
std::shared_ptr<OutputInterface> g_ioInterface; std::shared_ptr<OutputInterface> g_ioInterface;

27
ewolsa/music.cpp
View File

@ -34,11 +34,11 @@ void ewolsa::music::init() {
musicNextRead = -1; musicNextRead = -1;
musicPositionReading = 0; musicPositionReading = 0;
for (size_t iii=0; iii<musicListRead.size(); ++iii) { for (size_t iii=0; iii<musicListRead.size(); ++iii) {
if (musicListRead[iii] == NULL) { if (musicListRead[iii] == nullptr) {
continue; continue;
} }
delete musicListRead[iii]; delete musicListRead[iii];
musicListRead[iii] = NULL; musicListRead[iii] = nullptr;
} }
musicListRead.clear(); musicListRead.clear();
} }
@ -51,11 +51,11 @@ void ewolsa::music::unInit() {
musicNextRead = -1; musicNextRead = -1;
musicPositionReading = 0; musicPositionReading = 0;
for (size_t iii=0; iii<musicListRead.size(); ++iii) { for (size_t iii=0; iii<musicListRead.size(); ++iii) {
if (musicListRead[iii] == NULL) { if (musicListRead[iii] == nullptr) {
continue; continue;
} }
delete musicListRead[iii]; delete musicListRead[iii];
musicListRead[iii] = NULL; musicListRead[iii] = nullptr;
} }
musicListRead.clear(); musicListRead.clear();
} }
@ -71,7 +71,7 @@ void ewolsa::music::fading(int32_t _timeMs) {
void ewolsa::music::preLoad(const std::string& _file) { void ewolsa::music::preLoad(const std::string& _file) {
// check if music already existed ... // check if music already existed ...
for (size_t iii=0; iii<musicListRead.size(); ++iii) { for (size_t iii=0; iii<musicListRead.size(); ++iii) {
if (musicListRead[iii] == NULL) { if (musicListRead[iii] == nullptr) {
continue; continue;
} }
if (musicListRead[iii]->getName() == _file) { if (musicListRead[iii]->getName() == _file) {
@ -79,9 +79,9 @@ void ewolsa::music::preLoad(const std::string& _file) {
} }
} }
ewolsa::LoadedFile* tmp = new ewolsa::LoadedFile(_file, 2); ewolsa::LoadedFile* tmp = new ewolsa::LoadedFile(_file, 2);
if (tmp != NULL) { if (tmp != nullptr) {
/* /*
if (tmp->m_data == NULL) { if (tmp->m_data == nullptr) {
EWOLSA_ERROR("Music has no data ... : " << _file); EWOLSA_ERROR("Music has no data ... : " << _file);
delete(tmp); delete(tmp);
return; return;
@ -101,7 +101,7 @@ bool ewolsa::music::play(const std::string& _file) {
int32_t idMusic = -1; int32_t idMusic = -1;
// check if music already existed ... // check if music already existed ...
for (size_t iii=0; iii<musicListRead.size(); ++iii) { for (size_t iii=0; iii<musicListRead.size(); ++iii) {
if (musicListRead[iii] == NULL) { if (musicListRead[iii] == nullptr) {
continue; continue;
} }
if (musicListRead[iii]->getName() == _file) { if (musicListRead[iii]->getName() == _file) {
@ -182,23 +182,26 @@ void ewolsa::music::getData(int16_t * _bufferInterlace, int32_t _nbSample, int32
return; return;
} }
if ( musicCurrentRead >= musicListRead.size() if ( musicCurrentRead >= musicListRead.size()
|| musicListRead[musicCurrentRead] == NULL) { || musicListRead[musicCurrentRead] == nullptr) {
musicCurrentRead = -1; musicCurrentRead = -1;
musicPositionReading = 0; musicPositionReading = 0;
EWOLSA_ERROR("request read an unexisting audio track ... : " << musicCurrentRead << "/" << musicListRead.size()); EWOLSA_ERROR("request read an unexisting audio track ... : " << musicCurrentRead << "/" << musicListRead.size());
return; return;
} }
if (musicListRead[musicCurrentRead]->m_data == NULL) { if (musicListRead[musicCurrentRead]->m_data.size() == 0) {
return; return;
} }
int32_t processTimeMax = std::min(_nbSample*_nbChannels, musicListRead[musicCurrentRead]->m_nbSamples - musicPositionReading); int32_t processTimeMax = std::min(_nbSample*_nbChannels, musicListRead[musicCurrentRead]->m_nbSamples - musicPositionReading);
processTimeMax = std::max(0, processTimeMax); processTimeMax = std::max(0, processTimeMax);
int16_t * pointer = _bufferInterlace; int16_t * pointer = _bufferInterlace;
int16_t * newData = &musicListRead[musicCurrentRead]->m_data[musicPositionReading]; int16_t * newData = &musicListRead[musicCurrentRead]->m_data[musicPositionReading];
//EWOLSA_DEBUG("AUDIO : Play slot... nb sample : " << processTimeMax << " playTime=" <<m_playTime << " nbCannels=" << nbChannels); EWOLSA_DEBUG("AUDIO : Play slot... nb sample : " << processTimeMax << " nbCannels=" << _nbChannels << " chunkRequest=" << _nbSample);
for (int32_t iii=0; iii<processTimeMax; iii++) { for (int32_t iii=0; iii<processTimeMax; iii++) {
int32_t tmppp = *pointer + ((((int32_t)*newData)*musicVolumeApply)>>16); /*
int32_t tmppp = ((int32_t)*pointer) + ((((int32_t)*newData)*musicVolumeApply)>>16);
*pointer = std::avg(-32767, tmppp, 32766); *pointer = std::avg(-32767, tmppp, 32766);
*/
*pointer = *newData;
//EWOLSA_DEBUG("AUDIO : element : " << *pointer); //EWOLSA_DEBUG("AUDIO : element : " << *pointer);
pointer++; pointer++;
newData++; newData++;