void projectM::selectPrevious(const bool hardCut) {
if (m_presetChooser->empty())
return;
if (!hardCut) {
timeKeeper->StartSmoothing();
}
m_presetChooser->previousPreset(*m_presetPos);
if (!hardCut) {
switchPreset(m_activePreset2);
} else {
switchPreset(m_activePreset);
timeKeeper->StartPreset();
}
presetSwitchedEvent(hardCut, **m_presetPos);
// m_activePreset = m_presetPos->allocate();
// renderer->SetPipeline(m_activePreset->pipeline());
// renderer->setPresetName(m_activePreset->name());
//timeKeeper->StartPreset();
}
void projectM::selectNext(const bool hardCut) {
if (m_presetChooser->empty())
return;
m_presetChooser->nextPreset(*m_presetPos);
switchPreset(hardCut);
}
void projectM::selectRandom(const bool hardCut) {
if (m_presetChooser->empty())
return;
*m_presetPos = m_presetChooser->weightedRandom(hardCut);
switchPreset(hardCut);
}
void projectM::switchPreset(const bool hardCut) {
std::string result;
if (!hardCut) {
result = switchPreset(m_activePreset2);
} else {
result = switchPreset(m_activePreset);
if (result.empty())
timeKeeper->StartPreset();
}
if (result.empty() && !hardCut) {
timeKeeper->StartSmoothing();
}
if (result.empty())
presetSwitchedEvent(hardCut, **m_presetPos);
else
presetSwitchFailedEvent(hardCut, **m_presetPos, result);
}
void projectM::selectPreset(unsigned int index, bool hardCut)
{
if (m_presetChooser->empty())
return;
*m_presetPos = m_presetChooser->begin(index);
switchPreset(hardCut);
}
void projectM::selectRandom(const bool hardCut) {
if (m_presetChooser->empty())
return;
if (!hardCut) {
timeKeeper->StartSmoothing();
}
*m_presetPos = m_presetChooser->weightedRandom(hardCut);
if (!hardCut) {
switchPreset(m_activePreset2);
} else {
switchPreset(m_activePreset);
timeKeeper->StartPreset();
}
presetSwitchedEvent(hardCut, **m_presetPos);
}
void projectM::selectNext(const bool hardCut) {
if (m_presetChooser->empty())
return;
if (!hardCut) {
timeKeeper->StartSmoothing();
std::cout << "start smoothing" << std::endl;
}
m_presetChooser->nextPreset(*m_presetPos);
if (!hardCut) {
switchPreset(m_activePreset2);
} else {
switchPreset(m_activePreset);
timeKeeper->StartPreset();
}
presetSwitchedEvent(hardCut, **m_presetPos);
}
void projectM::selectPreset ( unsigned int index, bool hardCut)
{
if (m_presetChooser->empty())
return;
if (!hardCut) {
timeKeeper->StartSmoothing();
}
*m_presetPos = m_presetChooser->begin(index);
if (!hardCut) {
switchPreset(m_activePreset2);
} else {
switchPreset(m_activePreset);
timeKeeper->StartPreset();
}
presetSwitchedEvent(hardCut, **m_presetPos);
}
int projectM::initPresetTools()
{
/* Initializes the builtin function database */
BuiltinFuncs::init_builtin_func_db();
/* Initializes all infix operators */
Eval::init_infix_ops();
/* Set the seed to the current time in seconds */
srand ( time ( NULL ) );
std::string url = (m_flags & FLAG_DISABLE_PLAYLIST_LOAD) ? std::string() : settings().presetURL;
if ( ( m_presetLoader = new PresetLoader ( url) ) == 0 )
{
m_presetLoader = 0;
std::cerr << "[projectM] error allocating preset loader" << std::endl;
return PROJECTM_FAILURE;
}
if ( ( m_presetChooser = new PresetChooser ( *m_presetLoader ) ) == 0 )
{
delete ( m_presetLoader );
m_presetChooser = 0;
m_presetLoader = 0;
std::cerr << "[projectM] error allocating preset chooser" << std::endl;
return PROJECTM_FAILURE;
}
// Start the iterator
if (!m_presetPos)
m_presetPos = new PresetIterator();
// Initialize a preset queue position as well
// m_presetQueuePos = new PresetIterator();
// Start at end ptr- this allows next/previous to easily be done from this position.
*m_presetPos = m_presetChooser->end();
// Load idle preset
//std::cerr << "[projectM] Allocating idle preset..." << std::endl;
if (m_presetChooser->empty())
m_activePreset = IdlePreset::allocate ( presetInputs, presetOutputs );
else
switchPreset(m_activePreset, presetInputs, presetOutputs);
// Case where no valid presets exist in directory. Could also mean
// playlist initialization was deferred
//if ( m_presetChooser->empty() )
//{
//std::cerr << "[projectM] warning: no valid files found in preset directory \""
//<< m_presetLoader->directoryName() << "\"" << std::endl;
//}
//std::cerr << "[projectM] Idle preset allocated." << std::endl;
projectM_resetengine();
//std::cerr << "[projectM] engine has been reset." << std::endl;
return PROJECTM_SUCCESS;
}
DLLEXPORT void projectM::renderFrame()
{
#ifdef DEBUG
char fname[1024];
FILE *f = NULL;
int index = 0;
int x, y;
#endif
timeKeeper->UpdateTimers();
//printf("A:%f, B:%f, S:%f\n", timeKeeper->PresetProgressA(), timeKeeper->PresetProgressB(), timeKeeper->SmoothRatio());
mspf= ( int ) ( 1000.0/ ( float ) presetInputs.fps ); //milliseconds per frame
setupPresetInputs(&m_activePreset->presetInputs());
m_activePreset->presetInputs().frame = timeKeeper->PresetFrameA();
m_activePreset->presetInputs().progress= timeKeeper->PresetProgressA();
beatDetect->detectFromSamples();
//m_activePreset->evaluateFrame();
if ( renderer->noSwitch==false && !m_presetChooser->empty() )
{
if ( timeKeeper->PresetProgressA()>=1.0 && !timeKeeper->IsSmoothing())
{
timeKeeper->StartSmoothing();
// printf("Start Smooth\n");
// if(timeKeeper->IsSmoothing())printf("Confirmed\n");
switchPreset(m_activePreset2,
&m_activePreset->presetInputs() == &presetInputs ? presetInputs2 : presetInputs,
&m_activePreset->presetOutputs() == &presetOutputs ? presetOutputs2 : presetOutputs);
presetSwitchedEvent(false, **m_presetPos);
}
else if ( ( beatDetect->vol-beatDetect->vol_old>beatDetect->beat_sensitivity ) && timeKeeper->CanHardCut() )
{
// printf("Hard Cut\n");
switchPreset(m_activePreset, presetInputs, presetOutputs);
timeKeeper->StartPreset();
presetSwitchedEvent(true, **m_presetPos);
}
}
if ( timeKeeper->IsSmoothing() && timeKeeper->SmoothRatio() <= 1.0 && !m_presetChooser->empty() )
{
// printf("start thread\n");
assert ( m_activePreset.get() );
#ifdef USE_THREADS
pthread_cond_signal(&condition);
pthread_mutex_unlock( &mutex );
#endif
m_activePreset->evaluateFrame();
renderer->PerPixelMath ( &m_activePreset->presetOutputs(), &presetInputs );
renderer->WaveformMath ( &m_activePreset->presetOutputs(), &presetInputs, true );
#ifdef USE_THREADS
pthread_mutex_lock( &mutex );
#else
evaluateSecondPreset();
#endif
PresetMerger::MergePresets ( m_activePreset->presetOutputs(),m_activePreset2->presetOutputs(),timeKeeper->SmoothRatio(),presetInputs.gx, presetInputs.gy );
}
else
{
if ( timeKeeper->IsSmoothing() && timeKeeper->SmoothRatio() > 1.0 )
{
//printf("End Smooth\n");
m_activePreset = m_activePreset2;
timeKeeper->EndSmoothing();
}
//printf("Normal\n");
m_activePreset->evaluateFrame();
renderer->PerPixelMath ( &m_activePreset->presetOutputs(), &presetInputs );
renderer->WaveformMath ( &m_activePreset->presetOutputs(), &presetInputs, false );
}
// std::cout<< m_activePreset->absoluteFilePath()<<std::endl;
// renderer->presetName = m_activePreset->absoluteFilePath();
renderer->RenderFrame ( &m_activePreset->presetOutputs(), &presetInputs );
count++;
#ifndef WIN32
/** Frame-rate limiter */
/** Compute once per preset */
if ( this->count%100==0 )
{
this->renderer->realfps=100.0/ ( ( getTicks ( &timeKeeper->startTime )-this->fpsstart ) /1000 );
this->fpsstart=getTicks ( &timeKeeper->startTime );
}
int timediff = getTicks ( &timeKeeper->startTime )-this->timestart;
if ( timediff < this->mspf )
{
// printf("%s:",this->mspf-timediff);
int sleepTime = ( unsigned int ) ( this->mspf-timediff ) * 1000;
// DWRITE ( "usleep: %d\n", sleepTime );
if ( sleepTime > 0 && sleepTime < 100000 )
{
if ( usleep ( sleepTime ) != 0 ) {}}
}
this->timestart=getTicks ( &timeKeeper->startTime );
#endif /** !WIN32 */
}
int loadPresetDir(char * dir) {
struct dirent ** name_list;
char * preset_name;
int i, j, dir_size;
if (dir == NULL)
return ERROR;
if (chrono_order_preset_name_tree != NULL) {
if (PRESET_DEBUG) printf("loadPresetDir: previous directory doesn't appear to be closed!\n");
/* Let this slide for now */
}
/* Scan the entire directory, storing each entry in a dirent struct array that needs
to be freed later. For more information, consult scandir(3) in the man pages */
if ((dir_size = scandir(dir, &name_list, 0, alphasort)) < 0) {
if (PRESET_DEBUG) printf("loadPresetDir: failed to open directory \"%s\"\n", dir);
return ERROR;
}
chrono_order_preset_name_tree = create_splaytree(compare_int, copy_int, free_int);
/* Iterate through entire dirent name list, adding to the preset name list if it
is valid */
for (i = 0; ((i < dir_size) && (i < MAX_PRESETS_IN_DIR));i++) {
/* Only perform the next set of operations if the preset name
contains a valid extension */
if (is_valid_extension(name_list[i]->d_name)) {
/* Handle the out of memory case. My guess is xmms would
crash before this program would, but whatever...*/
if ((preset_name = (char*)malloc(MAX_PATH_SIZE)) == NULL) {
if (PRESET_DEBUG) printf("loadPresetDir: out of memory! \n");
/* Free the rest of the dirent name list */
for (j = i; j < dir_size; j++)
free(name_list[j]);
destroy_splaytree(chrono_order_preset_name_tree);
return OUTOFMEM_ERROR;
}
/* Now create the full path */
if (get_preset_path(&preset_name, dir, name_list[i]->d_name) < 0) {
if (PRESET_DEBUG) printf("loadPresetDir: failed to generate full preset path name!\n");
/* Free the rest of the dirent name list */
for (j = i; j < dir_size; j++)
free(name_list[j]);
destroy_splaytree(chrono_order_preset_name_tree);
return OUTOFMEM_ERROR;
}
/* Insert the character string into the splay tree, with the key being its sequence number */
splay_insert(preset_name, &preset_name_buffer_size, chrono_order_preset_name_tree);
preset_name_buffer_size++;
}
/* Free the dirent struct */
free(name_list[i]);
}
free(name_list);
/* No valid files in directory! */
if (chrono_order_preset_name_tree->root == NULL) {
if (PRESET_DEBUG) printf("loadPresetDir: no valid files in directory \"%s\"\n", dir);
destroy_splaytree(chrono_order_preset_name_tree);
chrono_order_preset_name_tree = NULL;
return FAILURE;
}
/* Start the prefix index right before the first entry, so next preset
starts at the top of the list */
preset_index = -1;
/* Start the first preset */
switchPreset(ALPHA_NEXT, HARD_CUT);
return SUCCESS;
}
