bool s_MIF_Listener::populate(fl_ContainerLayout* /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs = static_cast<const PX_ChangeRecord_Span *> (pcr);
PT_BufIndex bi = pcrs->getBufIndex();
_outputData(m_pDocument->getPointer(bi),pcrs->getLength());
return true;
}
case PX_ChangeRecord::PXT_InsertObject:
{
#if 0
// TODO decide how to indicate objects in MIF output.
const PX_ChangeRecord_Object * pcro = static_cast<const PX_ChangeRecord_Object *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
switch (pcro->getObjectType())
{
case PTO_Image:
return true;
case PTO_Field:
return true;
// todo: support these
case PTO_Hyperlink:
case PTO_Bookmark:
return true;
default:
UT_ASSERT(0);
return false;
}
#else
return true;
#endif
}
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
default:
UT_ASSERT(0);
return false;
}
}
bool s_RTF_ListenerGetProps::populate(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs = static_cast<const PX_ChangeRecord_Span *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
_openSpan(api);
PT_BufIndex bi = pcrs->getBufIndex();
_outputData(m_pDocument->getPointer(bi),pcrs->getLength());
return true;
}
case PX_ChangeRecord::PXT_InsertObject:
{
#if 0
const PX_ChangeRecord_Object * pcro = static_cast<const PX_ChangeRecord_Object *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
switch (pcro->getObjectType())
{
case PTO_Image:
_closeSpan();
_openTag("image",api);
return true;
case PTO_Field:
_closeSpan();
_openTag("field",api);
return true;
default:
UT_ASSERT_NOT_REACHED();
return false;
}
#endif
}
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
default:
UT_ASSERT_NOT_REACHED();
return false;
}
}
bool WordPerfect_Listener::populate(fl_ContainerLayout* /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs = static_cast<const PX_ChangeRecord_Span *>(pcr);
PT_BufIndex bi = pcrs->getBufIndex();
PT_AttrPropIndex api = pcr->getIndexAP();
if (api)
{
_openSpan(api);
}
_outputData(m_pDocument->getPointer(bi),pcrs->getLength());
if (api)
{
_closeSpan();
}
return true;
}
case PX_ChangeRecord::PXT_InsertObject:
{
}
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
default:
UT_ASSERT(0);
return false;
}
}
bool s_XSL_FO_Listener::populate(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs =
static_cast<const PX_ChangeRecord_Span *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
if (api)
{
_openSpan(api);
}
PT_BufIndex bi = pcrs->getBufIndex();
_outputData(m_pDocument->getPointer(bi),pcrs->getLength());
if (api)
{
_closeSpan();
}
return true;
}
case PX_ChangeRecord::PXT_InsertObject:
{
const PX_ChangeRecord_Object * pcro = static_cast<const PX_ChangeRecord_Object *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
switch (pcro->getObjectType())
{
case PTO_Image:
{
_handleImage(api);
return true;
}
case PTO_Field:
{
_handleField(pcro, api);
return true;
}
case PTO_Hyperlink:
{
_handleHyperlink(api);
return true;
}
case PTO_Bookmark:
{
_handleBookmark(api);
return true;
}
case PTO_Math:
{
_handleMath(api);
return true;
}
case PTO_Embed:
{
_handleEmbedded(api);
return true;
}
default:
{
UT_ASSERT(UT_TODO);
return true;
}
}
}
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
default:
UT_ASSERT(0);
return false;
}
}
int main(int argc, char *argv[])
{
//************************************************************
// Initialisation
//************************************************************
std::cout << "INIT" << std::endl;
srand((int)time(NULL));
if (argc < 3)
{
std::cerr << "not enough parameters" << std::endl << "usage : ./NeuralNetwork sample_sound.wav sound_to_process.wav [output_sound.wav]" << std::endl;
return EXIT_FAILURE;
}
// Charge les fichiers audio
WAV _inputWav, _sampleWav;
if (_inputWav.Read(argv[2]) || _sampleWav.Read(argv[1]))
{
std::cerr << "unable to read file" << std::endl;
return EXIT_FAILURE;
}
if (_inputWav.getChannels() != 1 || _sampleWav.getChannels() != 1)
{
std::cerr << "stereo sounds are not supported" << std::endl;
return EXIT_FAILURE;
}
if (_inputWav.getBit() != 16 || _sampleWav.getBit() != 16)
{
std::cerr << "sounds must be 16 bits" << std::endl;
return EXIT_FAILURE;
}
if (_inputWav.getSampleCount() < BUFFER_SIZE || _sampleWav.getSampleCount() < BUFFER_SIZE)
{
std::cerr << "sounds are too smalls" << std::endl;
return EXIT_FAILURE;
}
// init buffers
std::vector<kiss_fft_cpx> _fftIn(BUFFER_SIZE);
for (int i = 0; i < BUFFER_SIZE; i++)
{
_fftIn[i].r = ((short*) _sampleWav.getData())[i] / 32767.f;
_fftIn[i].i = 0.f;
}
// lance FFT
kiss_fft_cfg _fftCfg = kiss_fft_alloc(BUFFER_SIZE, 0, 0, 0);
std::vector<kiss_fft_cpx> _fftOut(BUFFER_SIZE);
kiss_fft(_fftCfg, _fftIn.data(), _fftOut.data());
normalizeFFT(_fftOut);
// Reseaux de neruones
std::vector<NeuralNetwork*> _pool (POOL_SIZE);
for (unsigned int i = 0; i < _pool.size(); i++)
{
NeuralNetwork* _network = new NeuralNetwork();
_pool[i] = _network;
}
Generator _generator;
std::vector<float> _generatorParam(GENERATOR_COUNT, 0.f);
std::vector<kiss_fft_cpx> _outGenerator(BUFFER_SIZE);
std::vector<kiss_fft_cpx> _fftGenerator(BUFFER_SIZE);
//************************************************************
// Algorithme génétique pour trouver un bon réseau de neurone
//************************************************************
for (int _generation = 0; _generation < GENERATION_COUNT; _generation++)
{
std::cout << "generation : " << _generation << std::endl;
for (unsigned int i = 0; i < _pool.size(); i++)
{
// test avec le reseau de neurone
_pool[i]->run(_fftOut, _generatorParam);
// genere le son
_generator.run(_generatorParam, _outGenerator, (float) _sampleWav.getSampleRate());
// FFT du signal généré
kiss_fft(_fftCfg, _outGenerator.data(), _fftGenerator.data());
normalizeFFT(_fftGenerator);
// calcul la distance entre les deux FFTs
float _distance = 0.f;
for (unsigned int j = 0; j < BUFFER_SIZE/2; j++)
{
_distance += fabs(_fftGenerator[j].r - _fftOut[j].r);
}
// plus le score est petit, mieux c'est
_pool[i]->mScore = _distance;
}
// Trie la pool dans l'ordre croissant de score
std::sort(_pool.begin(), _pool.end(), &NeuralNetwork::sortFct);
std::cout << "best network : " << _pool[0]->mScore << std::endl;
// croisement genetique entre les meilleurs réseaux de neurones
int _selection = (int)_pool.size() / 3;
for (int i = 0; i < _selection; i++)
{
NeuralNetwork* _nn = new NeuralNetwork(_pool[i], _pool[random(0, _selection)]);
// detruit les reseaux les plus mauvais et les remplace par des enfants
delete _pool[_pool.size() - 1 - i];
_pool[_pool.size() - 1 - i] = _nn;
}
}
//************************************************************
// Ecriture du son final
//************************************************************
// test avec le meilleur reseau de neurone
std::sort(_pool.begin(), _pool.end(), &NeuralNetwork::sortFct);
// genere le son
std::vector<short> _outputData(_inputWav.getSampleCount());
std::vector<float> _previousGeneratorParam(GENERATOR_COUNT, 0.f);
// le son est traité par morceau
for (unsigned int i = 0; i < _inputWav.getSampleCount() - BUFFER_SIZE; i += BUFFER_SIZE)
{
for (unsigned int j = 0; j < BUFFER_SIZE; j++)
{
_fftIn[j].r = ((short*) _inputWav.getData())[i + j] / 32767.f;
_fftIn[j].i = 0.f;
}
// fft
kiss_fft(_fftCfg, _fftIn.data(), _fftOut.data());
normalizeFFT(_fftOut);
// réseau de neurone
_pool[0]->run(_fftOut, _generatorParam);
// générateurs
_generator.run(_previousGeneratorParam, _generatorParam, _outGenerator, (float) _inputWav.getSampleRate(), i);
_previousGeneratorParam = _generatorParam;
// convertit en entier 16 bits
for (unsigned int j = 0; j < BUFFER_SIZE; j++)
{
_outputData[i + j] = (short) (32767.f * _outGenerator[j].r);
}
}
// écrit le son en sortie
_inputWav.setSampleCount(_outputData.size());
_inputWav.setData(_outputData.data(), _outputData.size() * sizeof(short));
std::string _outFile = "out.wav";
if (argc >= 4)
{
_outFile = argv[3];
}
std::cout << "write " << _outFile << std::endl;
_inputWav.Write(_outFile.c_str());
return EXIT_SUCCESS;
}
bool ODe_AbiDocListener::populate(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType()) {
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs =
static_cast<const PX_ChangeRecord_Span *> (pcr);
if (pcrs->getField()!=m_pCurrentField) {
_closeField();
}
PT_AttrPropIndex api = pcr->getIndexAP();
_openSpan(api);
PT_BufIndex bi = pcrs->getBufIndex();
UT_UTF8String utf8String (m_pDocument->getPointer(bi),
pcrs->getLength());
_outputData(m_pDocument->getPointer(bi), pcrs->getLength());
}
break;
case PX_ChangeRecord::PXT_InsertObject:
{
const PX_ChangeRecord_Object * pcro =
static_cast<const PX_ChangeRecord_Object *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
switch (pcro->getObjectType())
{
case PTO_Image:
{
_closeSpan();
_closeField();
_insertInlinedImage(api);
return true;
}
case PTO_Field:
{
_closeSpan();
_closeField();
_openField(pcro, api);
return true;
}
case PTO_Math:
{
_closeSpan();
_closeField();
_insertMath(api);
return true;
}
case PTO_Embed:
{
//TODO: we may want to save the actual chart xml one day,
// but saving the image will do for now
_closeSpan();
_closeField();
_insertEmbeddedImage(api);
return true;
}
case PTO_Bookmark:
{
_closeSpan();
_closeField();
const PP_AttrProp* pAP = NULL;
m_pDocument->getAttrProp(api,&pAP);
const gchar* pValue = NULL;
if(pAP && pAP->getAttribute("type",pValue) && pValue && (strcmp(pValue, "start") == 0)) {
_openBookmark(api);
} else {
_closeBookmark(api);
}
return true;
}
case PTO_Hyperlink:
{
_closeSpan();
_closeField();
const PP_AttrProp* pAP = NULL;
m_pDocument->getAttrProp(api,&pAP);
const gchar* pValue = NULL;
if(pAP && pAP->getAttribute("xlink:href",pValue) && pValue) {
_openHyperlink(api);
} else {
_closeHyperlink();
}
return true;
}
case PTO_Annotation:
{
_closeSpan();
_closeField();
return true;
}
default:
UT_ASSERT_HARMLESS(UT_TODO);
return true;
}
}
case PX_ChangeRecord::PXT_InsertFmtMark:
// fmt marks are temporary placeholders for props and
// attributes and should not be saved
return true;
default:
UT_ASSERT_HARMLESS(UT_TODO);
return true;
}
return true;
}
bool Text_Listener::populate(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs = static_cast<const PX_ChangeRecord_Span *>(pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
_handleDirMarker(api);
PT_BufIndex bi = pcrs->getBufIndex();
const UT_UCS4Char * pData = m_pDocument->getPointer(bi);
// first see if there is a pending marker (for block direction)
// and handle it
if(pData && m_eDirMarkerPending != DO_UNSET)
{
UT_UCS4Char cRLM = UCS_RLM;
UT_UCS4Char cLRM = UCS_LRM;
UT_BidiCharType type = UT_bidiGetCharType(*pData);
if(m_eDirMarkerPending == DO_RTL && type == UT_BIDI_RTL)
{
//the override corresponds to the marker, no marker needed
m_eDirMarkerPending = DO_UNSET;
}
else if(m_eDirMarkerPending == DO_RTL && type == UT_BIDI_LTR)
{
//need to issue marker
_outputData(&cRLM, 1);
m_eDirMarkerPending = DO_UNSET;
}
else if(m_eDirMarkerPending == DO_LTR && type == UT_BIDI_LTR)
{
//the override corresponds to the marker, no marker needed
m_eDirMarkerPending = DO_UNSET;
}
else if(m_eDirMarkerPending == DO_LTR && type == UT_BIDI_RTL)
{
//need to issue marker
_outputData(&cLRM, 1);
m_eDirMarkerPending = DO_UNSET;
}
}
_outputData(pData,pcrs->getLength());
return true;
}
case PX_ChangeRecord::PXT_InsertObject:
{
// TODO decide how to indicate objects in text output.
const PX_ChangeRecord_Object * pcro = static_cast<const PX_ChangeRecord_Object *>(pcr);
//PT_AttrPropIndex api = pcr->getIndexAP();
fd_Field* field;
switch (pcro->getObjectType())
{
case PTO_Image:
return true;
case PTO_Field:
// Lossy, but pretty much unavoidable
field = pcro->getField();
UT_return_val_if_fail(field, false);
m_pie->populateFields ();
if(field->getValue() != NULL)
m_pie->write(field->getValue());
return true;
case PTO_Bookmark:
return true;
case PTO_Hyperlink:
return true;
case PTO_Embed:
return true;
case PTO_Math:
return true;
case PTO_Annotation:
return true;
case PTO_RDFAnchor:
return true;
default:
UT_ASSERT_HARMLESS(UT_TODO);
return true;
}
}
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
default:
UT_ASSERT_HARMLESS(0);
return false;
}
}
void Text_Listener::_handleDirMarker(PT_AttrPropIndex api)
{
const PP_AttrProp * pAP = NULL;
bool bHaveProp = m_pDocument->getAttrProp (api, &pAP);
UT_UCS4Char * pMarker = NULL;
if (bHaveProp && pAP)
{
UT_UCS4Char cRLO = UCS_RLO;
UT_UCS4Char cLRO = UCS_LRO;
UT_UCS4Char cPDF = UCS_PDF;
const gchar *szValue = NULL;
if(pAP->getProperty("dir-override", szValue))
{
if(m_eDirOverride == DO_UNSET)
{
if(!g_ascii_strcasecmp(szValue, "rtl"))
{
m_eDirOverride = DO_RTL;
pMarker = &cRLO;
}
else if(!g_ascii_strcasecmp(szValue, "ltr"))
{
m_eDirOverride = DO_LTR;
pMarker = &cLRO;
}
}
else if(m_eDirOverride == DO_RTL)
{
if(!g_ascii_strcasecmp(szValue, "rtl"))
{
// no change
}
else if(!g_ascii_strcasecmp(szValue, "ltr"))
{
m_eDirOverride = DO_LTR;
pMarker = &cLRO;
}
}
else if(m_eDirOverride == DO_LTR)
{
if(!g_ascii_strcasecmp(szValue, "ltr"))
{
// no change
}
else if(!g_ascii_strcasecmp(szValue, "rtl"))
{
m_eDirOverride = DO_RTL;
pMarker = &cRLO;
}
}
else
{
UT_DEBUGMSG(("Text_Listener::_handleDirMarker: dir-override value '%s'\n",
szValue));
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
}
else
{
if(m_eDirOverride != DO_UNSET)
{
m_eDirOverride = DO_UNSET;
pMarker = &cPDF;
}
}
}
else
{
UT_DEBUGMSG(("Text_Listener::_handleDirMarker: no props! (bHaveProp %d, pAP %p)\n",
bHaveProp, pAP));
UT_ASSERT_HARMLESS( UT_SHOULD_NOT_HAPPEN );
}
// first see if there is a pending marker (for block direction)
// and handle it
if(pMarker && m_eDirMarkerPending != DO_UNSET)
{
UT_UCS4Char cRLM = UCS_RLM;
UT_UCS4Char cLRM = UCS_LRM;
if(m_eDirMarkerPending == DO_RTL && *pMarker == UCS_RLO)
{
//the override corresponds to the marker, no marker needed
m_eDirMarkerPending = DO_UNSET;
}
else if(m_eDirMarkerPending == DO_RTL && *pMarker == UCS_LRO)
{
//need to issue marker
_outputData(&cRLM, 1);
m_eDirMarkerPending = DO_UNSET;
}
else if(m_eDirMarkerPending == DO_LTR && *pMarker == UCS_LRO)
{
//the override corresponds to the marker, no marker needed
m_eDirMarkerPending = DO_UNSET;
}
else if(m_eDirMarkerPending == DO_LTR && *pMarker == UCS_RLO)
{
//need to issue marker
_outputData(&cLRM, 1);
m_eDirMarkerPending = DO_UNSET;
}
}
if(pMarker)
{
_outputData(pMarker, 1);
}
}
