void SoundLibraryPanel::on_songLoadAction()
{
QString songName = __sound_library_tree->currentItem()->text( 0 );
QString sDirectory = Preferences::get_instance()->getDataDirectory() + "songs";
QString sFilename = sDirectory + "/" + songName + ".h2song";
Hydrogen *engine = Hydrogen::get_instance();
if ( engine->getState() == STATE_PLAYING ) {
engine->sequencer_stop();
}
Song *pSong = Song::load( sFilename );
if ( pSong == NULL ) {
QMessageBox::information( this, "Hydrogen", trUtf8("Error loading song.") );
return;
}
// add the new loaded song in the "last used song" vector
Preferences *pPref = Preferences::get_instance();
std::vector<QString> recentFiles = pPref->getRecentFiles();
recentFiles.insert( recentFiles.begin(), sFilename );
pPref->setRecentFiles( recentFiles );
HydrogenApp* h2app = HydrogenApp::get_instance();
h2app->setSong( pSong );
//updateRecentUsedSongList();
engine->setSelectedPatternNumber( 0 );
}
void MainForm::action_file_new()
{
Hydrogen * pEngine = Hydrogen::get_instance();
if ( (pEngine->getState() == STATE_PLAYING) ) {
pEngine->sequencer_stop();
}
bool proceed = handleUnsavedChanges();
if(!proceed) {
return;
}
h2app->m_undoStack->clear();
pEngine->getTimeline()->m_timelinevector.clear();
Song * pSong = Song::get_empty_song();
pSong->set_filename( "" );
h2app->setSong(pSong);
pEngine->setSelectedPatternNumber( 0 );
h2app->getInstrumentRack()->getSoundLibraryPanel()->update_background_color();
h2app->getSongEditorPanel()->updatePositionRuler();
pEngine->getTimeline()->m_timelinetagvector.clear();
// update director tags
EventQueue::get_instance()->push_event( EVENT_METRONOME, 2 );
// update director songname
EventQueue::get_instance()->push_event( EVENT_METRONOME, 3 );
}
/* This method is called by Event dispacher thread ( GUI ) */
bool Playlist::loadSong (int songNumber)
{
Hydrogen* pHydrogen = Hydrogen::get_instance();
Preferences *pPref = Preferences::get_instance();
if ( pHydrogen->getState() == STATE_PLAYING )
pHydrogen->sequencer_stop();
/* Load Song from file */
QString selected = pHydrogen->m_PlayList[ songNumber ].m_hFile;
Song *pSong = Song::load( selected );
if ( ! pSong ) return false;
setSelectedSongNr( songNumber );
setActiveSongNumber( songNumber );
pHydrogen->setSong( pSong );
pPref->setLastSongFilename( pSong->get_filename() );
vector<QString> recentFiles = pPref->getRecentFiles();
recentFiles.insert( recentFiles.begin(), selected );
pPref->setRecentFiles( recentFiles );
execScript( songNumber );
return true;
}
void MainForm::action_file_save_as()
{
Hydrogen* pEngine = Hydrogen::get_instance();
if ( pEngine->getState() == STATE_PLAYING ) {
pEngine->sequencer_stop();
}
//std::auto_ptr<QFileDialog> fd( new QFileDialog );
QFileDialog fd(this);
fd.setFileMode( QFileDialog::AnyFile );
fd.setFilter( trUtf8("Hydrogen Song (*.h2song)") );
fd.setAcceptMode( QFileDialog::AcceptSave );
fd.setWindowTitle( trUtf8( "Save song" ) );
fd.setSidebarUrls( fd.sidebarUrls() << QUrl::fromLocalFile( Filesystem::songs_dir() ) );
Song *song = pEngine->getSong();
QString defaultFilename;
QString lastFilename = song->get_filename();
if ( lastFilename.isEmpty() ) {
defaultFilename = pEngine->getSong()->__name;
defaultFilename += ".h2song";
}
else {
defaultFilename = lastFilename;
}
fd.selectFile( defaultFilename );
QString filename;
if (fd.exec() == QDialog::Accepted) {
filename = fd.selectedFiles().first();
}
if ( !filename.isEmpty() ) {
QString sNewFilename = filename;
if ( sNewFilename.endsWith(".h2song") == false ) {
filename += ".h2song";
}
song->set_filename(filename);
action_file_save();
}
h2app->setScrollStatusBarMessage( trUtf8("Song saved as.") + QString(" Into: ") + defaultFilename, 2000 );
h2app->updateWindowTitle();
}
void PlaylistDialog::nodePlayBTN( Button* ref )
{
Hydrogen *pEngine = Hydrogen::get_instance();
HydrogenApp *pH2App = HydrogenApp::get_instance();
if (ref->isPressed()) {
QTreeWidgetItem* m_pPlaylistItem = m_pPlaylistTree->currentItem();
if ( m_pPlaylistItem == NULL ){
QMessageBox::information ( this, "Hydrogen", trUtf8 ( "No valid song selected!" ) );
m_pPlayBtn->setPressed(false);
return;
}
QString selected = "";
selected = m_pPlaylistItem->text ( 0 );
if( selected == pEngine->getSong()->get_filename()){
pEngine->sequencer_play();
return;
}
if ( pEngine->getState() == STATE_PLAYING ){
pEngine->sequencer_stop();
}
Song *pSong = Song::load ( selected );
if ( pSong == NULL ){
QMessageBox::information ( this, "Hydrogen", trUtf8 ( "Error loading song." ) );
m_pPlayBtn->setPressed(false);
return;
}
QTreeWidget* m_pPlaylist = m_pPlaylistTree;
int index = m_pPlaylist->indexOfTopLevelItem ( m_pPlaylistItem );
Playlist::get_instance()->setActiveSongNumber( index );
pH2App->setSong ( pSong );
pEngine->setSelectedPatternNumber ( 0 );
pEngine->sequencer_play();
}else
{
pEngine->sequencer_stop();
pH2App->setStatusBarMessage(trUtf8("Pause."), 5000);
}
}
/**
* The handleAction method is the heard of the MidiActionManager class.
* It executes the operations that are needed to carry the desired action.
*/
bool MidiActionManager::handleAction( MidiAction * pAction ){
Hydrogen *pEngine = Hydrogen::get_instance();
/*
return false if action is null
(for example if no Action exists for an event)
*/
if( pAction == NULL ) return false;
QString sActionString = pAction->getType();
if( sActionString == "PLAY" )
{
int nState = pEngine->getState();
if ( nState == STATE_READY ){
pEngine->sequencer_play();
}
return true;
}
if( sActionString == "PLAY/STOP_TOGGLE" || sActionString == "PLAY/PAUSE_TOGGLE" )
{
int nState = pEngine->getState();
switch ( nState )
{
case STATE_READY:
pEngine->sequencer_play();
break;
case STATE_PLAYING:
if( sActionString == "PLAY/STOP_TOGGLE" ) pEngine->setPatternPos( 0 );
pEngine->sequencer_stop();
pEngine->setTimelineBpm();
break;
default:
ERRORLOG( "[Hydrogen::ActionManager(PLAY): Unhandled case" );
}
return true;
}
if( sActionString == "PAUSE" )
{
pEngine->sequencer_stop();
return true;
}
if( sActionString == "STOP" )
{
pEngine->sequencer_stop();
pEngine->setPatternPos( 0 );
pEngine->setTimelineBpm();
return true;
}
if( sActionString == "MUTE" ){
//mutes the master, not a single strip
pEngine->getSong()->__is_muted = true;
return true;
}
if( sActionString == "UNMUTE" ){
pEngine->getSong()->__is_muted = false;
return true;
}
if( sActionString == "MUTE_TOGGLE" ){
pEngine->getSong()->__is_muted = !Hydrogen::get_instance()->getSong()->__is_muted;
return true;
}
if( sActionString == "BEATCOUNTER" ){
pEngine->handleBeatCounter();
return true;
}
if( sActionString == "TAP_TEMPO" ){
pEngine->onTapTempoAccelEvent();
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN" ){
bool ok;
int row = pAction->getParameter1().toInt(&ok,10);
if( row> pEngine->getSong()->get_pattern_list()->size() -1 )
return false;
if(Preferences::get_instance()->patternModePlaysSelected())
pEngine->setSelectedPatternNumber( row );
else
pEngine->sequencer_setNextPattern( row, false, true );
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN_RELATIVE" ){
bool ok;
if(!Preferences::get_instance()->patternModePlaysSelected())
{
return true;
}
int row = pEngine->getSelectedPatternNumber() + pAction->getParameter1().toInt(&ok,10);
if( row> pEngine->getSong()->get_pattern_list()->size() -1 )
{
return false;
}
pEngine->setSelectedPatternNumber( row );
return true;
}
if( sActionString == "SELECT_PREV_PATTERN_RELATIVE" ){
bool ok;
if(!Preferences::get_instance()->patternModePlaysSelected())
return true;
int row = pEngine->getSelectedPatternNumber() - pAction->getParameter1().toInt(&ok,10);
if( row < 0 )
return false;
pEngine->setSelectedPatternNumber( row );
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN_CC_ABSOLUT" ){
bool ok;
int row = pAction->getParameter2().toInt(&ok,10);
if( row> pEngine->getSong()->get_pattern_list()->size() -1 )
return false;
if(Preferences::get_instance()->patternModePlaysSelected())
pEngine->setSelectedPatternNumber( row );
else
return true;// only usefully in normal pattern mode
return true;
}
if( sActionString == "SELECT_NEXT_PATTERN_PROMPTLY" ){// obsolete, use SELECT_NEXT_PATTERN_CC_ABSOLUT instead
bool ok;
int row = pAction->getParameter2().toInt(&ok,10);
pEngine->setSelectedPatternNumberWithoutGuiEvent( row );
return true;
}
if( sActionString == "SELECT_AND_PLAY_PATTERN"){
bool ok;
int row = pAction->getParameter1().toInt(&ok,10);
pEngine->setSelectedPatternNumber( row );
pEngine->sequencer_setNextPattern( row, false, true );
int nState = pEngine->getState();
if ( nState == STATE_READY ){
pEngine->sequencer_play();
}
return true;
}
if( sActionString == "SELECT_INSTRUMENT" ){
bool ok;
int instrument_number = pAction->getParameter2().toInt(&ok,10) ;
if ( pEngine->getSong()->get_instrument_list()->size() < instrument_number )
instrument_number = pEngine->getSong()->get_instrument_list()->size() -1;
pEngine->setSelectedInstrumentNumber( instrument_number );
return true;
}
if( sActionString == "EFFECT1_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 0 , fx_param );
}
if( sActionString == "EFFECT2_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 1 , fx_param );
}
if( sActionString == "EFFECT3_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 2 , fx_param );
}
if( sActionString == "EFFECT4_LEVEL_ABSOLUTE" ){
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int fx_param = pAction->getParameter2().toInt(&ok,10);
setAbsoluteFXLevel( nLine, 3 , fx_param );
}
if( sActionString == "MASTER_VOLUME_RELATIVE" ){
//increments/decrements the volume of the whole song
bool ok;
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
if( vol_param != 0 ){
if ( vol_param == 1 && song->get_volume() < 1.5 ){
song->set_volume( song->get_volume() + 0.05 );
} else {
if( song->get_volume() >= 0.0 ){
song->set_volume( song->get_volume() - 0.05 );
}
}
} else {
song->set_volume( 0 );
}
}
if( sActionString == "MASTER_VOLUME_ABSOLUTE" ){
//sets the volume of a master output to a given level (percentage)
bool ok;
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
if( vol_param != 0 ){
song->set_volume( 1.5* ( (float) (vol_param / 127.0 ) ));
} else {
song->set_volume( 0 );
}
}
if( sActionString == "STRIP_VOLUME_RELATIVE" ){
//increments/decrements the volume of one mixer strip
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if ( instr == NULL) return 0;
if( vol_param != 0 ){
if ( vol_param == 1 && instr->get_volume() < 1.5 ){
instr->set_volume( instr->get_volume() + 0.1 );
} else {
if( instr->get_volume() >= 0.0 ){
instr->set_volume( instr->get_volume() - 0.1 );
}
}
} else {
instr->set_volume( 0 );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
if( sActionString == "STRIP_VOLUME_ABSOLUTE" ){
//sets the volume of a mixer strip to a given level (percentage)
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int vol_param = pAction->getParameter2().toInt(&ok,10);
Hydrogen::get_instance()->setSelectedInstrumentNumber( nLine );
Hydrogen *engine = Hydrogen::get_instance();
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if ( instr == NULL) return 0;
if( vol_param != 0 ){
instr->set_volume( 1.5* ( (float) (vol_param / 127.0 ) ));
} else {
instr->set_volume( 0 );
}
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
}
if( sActionString == "PAN_ABSOLUTE" ){
// sets the absolute panning of a given mixer channel
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int pan_param = pAction->getParameter2().toInt(&ok,10);
float pan_L;
float pan_R;
Hydrogen *engine = Hydrogen::get_instance();
engine->setSelectedInstrumentNumber( nLine );
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if( instr == NULL )
return false;
pan_L = instr->get_pan_l();
pan_R = instr->get_pan_r();
// pan
float fPanValue = 0.0;
if (pan_R == 1.0) {
fPanValue = 1.0 - (pan_L / 2.0);
}
else {
fPanValue = pan_R / 2.0;
}
fPanValue = 1 * ( ((float) pan_param) / 127.0 );
if (fPanValue >= 0.5) {
pan_L = (1.0 - fPanValue) * 2;
pan_R = 1.0;
}
else {
pan_L = 1.0;
pan_R = fPanValue * 2;
}
instr->set_pan_l( pan_L );
instr->set_pan_r( pan_R );
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
return true;
}
if( sActionString == "PAN_RELATIVE" ){
// changes the panning of a given mixer channel
// this is useful if the panning is set by a rotary control knob
bool ok;
int nLine = pAction->getParameter1().toInt(&ok,10);
int pan_param = pAction->getParameter2().toInt(&ok,10);
float pan_L;
float pan_R;
Hydrogen *engine = Hydrogen::get_instance();
engine->setSelectedInstrumentNumber( nLine );
Song *song = engine->getSong();
InstrumentList *instrList = song->get_instrument_list();
Instrument *instr = instrList->get( nLine );
if( instr == NULL )
return false;
pan_L = instr->get_pan_l();
pan_R = instr->get_pan_r();
// pan
float fPanValue = 0.0;
if (pan_R == 1.0) {
fPanValue = 1.0 - (pan_L / 2.0);
}
else {
fPanValue = pan_R / 2.0;
}
if( pan_param == 1 && fPanValue < 1 ){
fPanValue += 0.05;
}
if( pan_param != 1 && fPanValue > 0 ){
fPanValue -= 0.05;
}
if (fPanValue >= 0.5) {
pan_L = (1.0 - fPanValue) * 2;
pan_R = 1.0;
}
else {
pan_L = 1.0;
pan_R = fPanValue * 2;
}
instr->set_pan_l( pan_L );
instr->set_pan_r( pan_R );
Hydrogen::get_instance()->setSelectedInstrumentNumber(nLine);
return true;
}
if( sActionString == "BPM_CC_RELATIVE" ){
/*
* increments/decrements the BPM
* this is useful if the bpm is set by a rotary control knob
*/
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
//second parameter of cc command
//this value should be 1 to decrement and something other then 1 to increment the bpm
int cc_param = 1;
//this Action should be triggered only by CC commands
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
cc_param = pAction->getParameter2().toInt(&ok,10);
if( lastBpmChangeCCParameter == -1)
{
lastBpmChangeCCParameter = cc_param;
}
Song* pSong = pEngine->getSong();
if ( lastBpmChangeCCParameter >= cc_param && pSong->__bpm < 300) {
pEngine->setBPM( pSong->__bpm - 1*mult );
}
if ( lastBpmChangeCCParameter < cc_param && pSong->__bpm > 40 ) {
pEngine->setBPM( pSong->__bpm + 1*mult );
}
lastBpmChangeCCParameter = cc_param;
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == "BPM_FINE_CC_RELATIVE" ){
/*
* increments/decrements the BPM
* this is useful if the bpm is set by a rotary control knob
*/
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
//second parameter of cc command
//this value should be 1 to decrement and something other then 1 to increment the bpm
int cc_param = 1;
//this Action should be triggered only by CC commands
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
cc_param = pAction->getParameter2().toInt(&ok,10);
if( lastBpmChangeCCParameter == -1)
{
lastBpmChangeCCParameter = cc_param;
}
Song* pSong = pEngine->getSong();
if ( lastBpmChangeCCParameter >= cc_param && pSong->__bpm < 300) {
pEngine->setBPM( pSong->__bpm - 0.01*mult );
}
if ( lastBpmChangeCCParameter < cc_param && pSong->__bpm > 40 ) {
pEngine->setBPM( pSong->__bpm + 0.01*mult );
}
lastBpmChangeCCParameter = cc_param;
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == "BPM_INCR" ){
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
Song* pSong = pEngine->getSong();
if (pSong->__bpm < 300) {
pEngine->setBPM( pSong->__bpm + 1*mult );
}
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == "BPM_DECR" ){
AudioEngine::get_instance()->lock( RIGHT_HERE );
int mult = 1;
bool ok;
mult = pAction->getParameter1().toInt(&ok,10);
Song* pSong = pEngine->getSong();
if (pSong->__bpm > 40 ) {
pEngine->setBPM( pSong->__bpm - 1*mult );
}
AudioEngine::get_instance()->unlock();
return true;
}
if( sActionString == ">>_NEXT_BAR"){
pEngine->setPatternPos(pEngine->getPatternPos() +1 );
pEngine->setTimelineBpm();
return true;
}
if( sActionString == "<<_PREVIOUS_BAR"){
pEngine->setPatternPos(pEngine->getPatternPos() -1 );
pEngine->setTimelineBpm();
return true;
}
if( sActionString == "PLAYLIST_SONG"){
bool ok;
int songnumber = pAction->getParameter2().toInt(&ok,10);
return setSong( songnumber );
}
if( sActionString == "PLAYLIST_NEXT_SONG"){
int songnumber = Playlist::get_instance()->getActiveSongNumber();
return setSong( ++songnumber );
}
if( sActionString == "PLAYLIST_PREV_SONG"){
int songnumber = Playlist::get_instance()->getActiveSongNumber();
return setSong( --songnumber );
}
if( sActionString == "RECORD_READY"){
if ( pEngine->getState() != STATE_PLAYING ) {
if (!Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(true);
}
else {
Preferences::get_instance()->setRecordEvents(false);
}
}
return true;
}
if( sActionString == "RECORD/STROBE_TOGGLE"){
if (!Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(true);
}
else {
Preferences::get_instance()->setRecordEvents(false);
}
return true;
}
if( sActionString == "RECORD_STROBE"){
if (!Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(true);
}
return true;
}
if( sActionString == "RECORD_EXIT"){
if (Preferences::get_instance()->getRecordEvents()) {
Preferences::get_instance()->setRecordEvents(false);
}
return true;
}
if( sActionString == "TOGGLE_METRONOME"){
Preferences::get_instance()->m_bUseMetronome = !Preferences::get_instance()->m_bUseMetronome;
return true;
}
if( sActionString == "UNDO_ACTION"){
EventQueue::get_instance()->push_event( EVENT_UNDO_REDO, 0);// 0 = undo
return true;
}
if( sActionString == "REDO_ACTION"){
EventQueue::get_instance()->push_event( EVENT_UNDO_REDO, 1);// 1 = redo
return true;
}
return false;
}
int main(int argc, char *argv[])
{
try {
// Options...
char *cp;
struct option *op;
char opts[NELEM(long_opts) * 3 + 1];
// Build up the short option QString
cp = opts;
for (op = long_opts; op < &long_opts[NELEM(long_opts)]; op++) {
*cp++ = op->val;
if (op->has_arg)
*cp++ = ':';
if (op->has_arg == optional_argument )
*cp++ = ':'; // gets another one
}
// Deal with the options
QString songFilename;
QString playlistFilename;
QString outFilename = NULL;
QString sSelectedDriver;
bool showVersionOpt = false;
const char* logLevelOpt = "Error";
bool showHelpOpt = false;
QString drumkitName;
QString drumkitToLoad;
short bits = 16;
int rate = 44100;
short interpolation = 0;
#ifdef H2CORE_HAVE_JACKSESSION
QString sessionId;
#endif
int c;
while ( 1 ) {
c = getopt_long(argc, argv, opts, long_opts, NULL);
if ( c == -1 ) break;
switch(c) {
case 'd':
sSelectedDriver = QString::fromLocal8Bit(optarg);
break;
case 's':
songFilename = QString::fromLocal8Bit(optarg);
break;
case 'p':
playlistFilename = QString::fromLocal8Bit(optarg);
break;
case 'o':
outFilename = QString::fromLocal8Bit(optarg);
break;
case 'i':
//install h2drumkit
drumkitName = QString::fromLocal8Bit(optarg);
break;
case 'k':
//load Drumkit
drumkitToLoad = QString::fromLocal8Bit(optarg);
break;
case 'r':
rate = strtol(optarg, NULL, 10);
break;
case 'b':
bits = strtol(optarg, NULL, 10);
break;
case 'v':
showVersionOpt = true;
break;
case 'V':
logLevelOpt = (optarg) ? optarg : "Warning";
break;
#ifdef H2CORE_HAVE_JACKSESSION
case 'S':
sessionId = QString::fromLocal8Bit(optarg);
break;
#endif
case 'h':
case '?':
showHelpOpt = true;
break;
}
}
if ( showVersionOpt ) {
cout << get_version() << endl;
exit(0);
}
showInfo();
if ( showHelpOpt ) {
showUsage();
exit(0);
}
// Man your battle stations... this is not a drill.
Logger* logger = Logger::bootstrap( Logger::parse_log_level( logLevelOpt ) );
Object::bootstrap( logger, logger->should_log( Logger::Debug ) );
Filesystem::bootstrap( logger );
MidiMap::create_instance();
Preferences::create_instance();
Preferences* preferences = Preferences::get_instance();
// See below for Hydrogen.
___INFOLOG( QString("Using QT version ") + QString( qVersion() ) );
___INFOLOG( "Using data path: " + Filesystem::sys_data_path() );
#ifdef H2CORE_HAVE_LASH
LashClient::create_instance("hydrogen", "Hydrogen", &argc, &argv);
LashClient* lashClient = LashClient::get_instance();
#endif
if ( ! drumkitName.isEmpty() ){
Drumkit::install( drumkitName );
exit(0);
}
if (sSelectedDriver == "auto") {
preferences->m_sAudioDriver = "Auto";
}
else if (sSelectedDriver == "jack") {
preferences->m_sAudioDriver = "Jack";
}
else if ( sSelectedDriver == "oss" ) {
preferences->m_sAudioDriver = "Oss";
}
else if ( sSelectedDriver == "alsa" ) {
preferences->m_sAudioDriver = "Alsa";
}
else if (sSelectedDriver == "CoreAudio") {
preferences->m_sAudioDriver = "CoreAudio";
}
else if (sSelectedDriver == "PulseAudio") {
preferences->m_sAudioDriver = "PulseAudio";
}
#ifdef H2CORE_HAVE_LASH
if ( preferences->useLash() && lashClient->isConnected() ) {
lash_event_t* lash_event = lashClient->getNextEvent();
if (lash_event && lash_event_get_type(lash_event) == LASH_Restore_File) {
// notify client that this project was not a new one
lashClient->setNewProject(false);
songFilename = "";
songFilename.append( QString::fromLocal8Bit(lash_event_get_string(lash_event)) );
songFilename.append("/hydrogen.h2song");
//Logger::get_instance()->log("[LASH] Restore file: " + songFilename);
lash_event_destroy(lash_event);
} else if (lash_event) {
//Logger::get_instance()->log("[LASH] ERROR: Instead of restore file got event: " + lash_event_get_type(lash_event));
lash_event_destroy(lash_event);
}
}
#endif
#ifdef H2CORE_HAVE_JACKSESSION
if (!sessionId.isEmpty()) {
preferences->setJackSessionUUID ( sessionId );
/* imo, jack sessions use jack as default audio driver.
* hydrogen remember last used audiodriver.
* here we make it save that hydrogen start in a jacksession case
* every time with jack as audio driver
*/
preferences->m_sAudioDriver = "Jack";
}
/* the use of applicationFilePath() make it
* possible to use different executables.
* for example if you start hydrogen from a local
* build directory.
*/
// QString path = pQApp->applicationFilePath();
// preferences->setJackSessionApplicationPath ( path );
#endif
Hydrogen::create_instance();
Hydrogen *pHydrogen = Hydrogen::get_instance();
Song *pSong = NULL;
Playlist *pPlaylist = NULL;
// Load playlist
if ( ! playlistFilename.isEmpty() ) {
pPlaylist = Playlist::load ( playlistFilename );
if ( ! pPlaylist ) {
___ERRORLOG( "Error loading the playlist" );
return 0;
}
/* Load first song */
preferences->setLastPlaylistFilename( playlistFilename );
pPlaylist->loadSong( 0 );
pSong = pHydrogen->getSong();
show_playlist ( pHydrogen, pPlaylist->getActiveSongNumber() );
}
// Load song - if wasn't already loaded with playlist
if ( ! pSong ) {
if ( !songFilename.isEmpty() ) {
pSong = Song::load( songFilename );
} else {
/* Try load last song */
bool restoreLastSong = preferences->isRestoreLastSongEnabled();
QString filename = preferences->getLastSongFilename();
if ( restoreLastSong && ( !filename.isEmpty() ))
pSong = Song::load( filename );
}
/* Still not loaded */
if (! pSong) {
___INFOLOG("Starting with empty song");
pSong = Song::get_empty_song();
pSong->set_filename( "" );
}
pHydrogen->setSong( pSong );
preferences->setLastSongFilename( songFilename );
}
if ( ! drumkitToLoad.isEmpty() ){
Drumkit* drumkitInfo = Drumkit::load_by_name( drumkitToLoad, true );
if ( drumkitInfo ) {
pHydrogen->loadDrumkit( drumkitInfo );
} else {
___ERRORLOG ( "Error loading the drumkit" );
}
}
AudioEngine* AudioEngine = AudioEngine::get_instance();
Sampler* sampler = AudioEngine->get_sampler();
switch ( interpolation ) {
case 1:
sampler->setInterpolateMode( Sampler::COSINE );
break;
case 2:
sampler->setInterpolateMode( Sampler::THIRD );
break;
case 3:
sampler->setInterpolateMode( Sampler::CUBIC );
break;
case 4:
sampler->setInterpolateMode( Sampler::HERMITE );
break;
case 0:
default:
sampler->setInterpolateMode( Sampler::LINEAR );
}
EventQueue *pQueue = EventQueue::get_instance();
signal(SIGINT, signal_handler);
bool ExportMode = false;
if ( ! outFilename.isEmpty() ) {
pHydrogen->startExportSong ( outFilename, rate, bits );
cout << "Export Progress ... ";
bool ExportMode = true;
}
// Interactive mode
while ( ! quit ) {
/* FIXME: Someday here will be The Real CLI ;-) */
Event event = pQueue->pop_event();
// if ( event.type > 0) cout << "EVENT TYPE: " << event.type << endl;
/* Event handler */
switch ( event.type ) {
case EVENT_PROGRESS: /* event used only in export mode */
if ( ! ExportMode ) break;
if ( event.value < 100 ) {
cout << "\rExport Progress ... " << event.value << "%";
} else {
cout << "\rExport Progress ... DONE" << endl;
quit = true;
}
break;
case EVENT_PLAYLIST_LOADSONG: /* Load new song on MIDI event */
if ( pPlaylist->loadSong ( event.value ) ) {
pSong = pHydrogen->getSong();
show_playlist ( pHydrogen, pPlaylist->getActiveSongNumber() );
}
break;
case EVENT_NONE: /* Sleep if there is no more events */
Sleeper::msleep ( 100 );
break;
}
}
if ( pHydrogen->getState() == STATE_PLAYING )
pHydrogen->sequencer_stop();
delete pSong;
delete pPlaylist;
delete pQueue;
delete pHydrogen;
delete preferences;
delete AudioEngine;
delete MidiMap::get_instance();
delete MidiActionManager::get_instance();
___INFOLOG( "Quitting..." );
delete Logger::get_instance();
int nObj = Object::objects_count();
if (nObj != 0) {
cerr << "\n\n\n " << nObj << " alive objects\n\n" << endl << endl;
Object::write_objects_map_to_cerr();
}
}
catch ( const H2Exception& ex ) {
cerr << "[main] Exception: " << ex.what() << endl;
}
catch (...) {
cerr << "[main] Unknown exception X-(" << endl;
}
return 0;
}
void Sampler::setPlayingNotelength( Instrument* instrument, unsigned long ticks, unsigned long noteOnTick )
{
if ( instrument ) { // stop all notes using this instrument
Hydrogen *pEngine = Hydrogen::get_instance();
Song* mSong = pEngine->getSong();
int selectedpattern = pEngine->__get_selected_PatterNumber();
Pattern* currentPattern = NULL;
if ( mSong->get_mode() == Song::PATTERN_MODE ||
( pEngine->getState() != STATE_PLAYING )){
PatternList *pPatternList = mSong->get_pattern_list();
if ( ( selectedpattern != -1 )
&& ( selectedpattern < ( int )pPatternList->size() ) ) {
currentPattern = pPatternList->get( selectedpattern );
}
}else
{
std::vector<PatternList*> *pColumns = mSong->get_pattern_group_vector();
// Pattern *pPattern = NULL;
int pos = pEngine->getPatternPos() +1;
for ( int i = 0; i < pos; ++i ) {
PatternList *pColumn = ( *pColumns )[i];
currentPattern = pColumn->get( 0 );
}
}
if ( currentPattern ) {
int patternsize = currentPattern->get_length();
for ( unsigned nNote = 0; nNote < currentPattern->get_length(); nNote++ ) {
const Pattern::notes_t* notes = currentPattern->get_notes();
FOREACH_NOTE_CST_IT_BOUND(notes,it,nNote) {
Note *pNote = it->second;
if ( pNote!=NULL ) {
if( !Preferences::get_instance()->__playselectedinstrument ){
if ( pNote->get_instrument() == instrument
&& pNote->get_position() == noteOnTick ) {
AudioEngine::get_instance()->lock( RIGHT_HERE );
if ( ticks > patternsize )
ticks = patternsize - noteOnTick;
pNote->set_length( ticks );
Hydrogen::get_instance()->getSong()->__is_modified = true;
AudioEngine::get_instance()->unlock(); // unlock the audio engine
}
}else
{
if ( pNote->get_instrument() == pEngine->getSong()->get_instrument_list()->get( pEngine->getSelectedInstrumentNumber())
&& pNote->get_position() == noteOnTick ) {
AudioEngine::get_instance()->lock( RIGHT_HERE );
if ( ticks > patternsize )
ticks = patternsize - noteOnTick;
pNote->set_length( ticks );
Hydrogen::get_instance()->getSong()->__is_modified = true;
AudioEngine::get_instance()->unlock(); // unlock the audio engine
}
}
}
}
}
}
}
/// Render a note
/// Return 0: the note is not ended
/// Return 1: the note is ended
unsigned Sampler::__render_note( Note* pNote, unsigned nBufferSize, Song* pSong )
{
//infoLog( "[renderNote] instr: " + pNote->getInstrument()->m_sName );
assert( pSong );
unsigned int nFramepos;
Hydrogen* pEngine = Hydrogen::get_instance();
AudioOutput* audio_output = pEngine->getAudioOutput();
if ( pEngine->getState() == STATE_PLAYING ) {
nFramepos = audio_output->m_transport.m_nFrames;
} else {
// use this to support realtime events when not playing
nFramepos = pEngine->getRealtimeFrames();
}
Instrument *pInstr = pNote->get_instrument();
if ( !pInstr ) {
ERRORLOG( "NULL instrument" );
return 1;
}
float fLayerGain = 1.0;
float fLayerPitch = 0.0;
// scelgo il sample da usare in base alla velocity
Sample *pSample = NULL;
for ( unsigned nLayer = 0; nLayer < MAX_LAYERS; ++nLayer ) {
InstrumentLayer *pLayer = pInstr->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
break;
}
}
if ( !pSample ) {
QString dummy = QString( "NULL sample for instrument %1. Note velocity: %2" ).arg( pInstr->get_name() ).arg( pNote->get_velocity() );
WARNINGLOG( dummy );
return 1;
}
if ( pNote->get_sample_position() >= pSample->get_frames() ) {
WARNINGLOG( "sample position out of bounds. The layer has been resized during note play?" );
return 1;
}
int noteStartInFrames = ( int ) ( pNote->get_position() * audio_output->m_transport.m_nTickSize ) + pNote->get_humanize_delay();
int nInitialSilence = 0;
if ( noteStartInFrames > ( int ) nFramepos ) { // scrivo silenzio prima dell'inizio della nota
nInitialSilence = noteStartInFrames - nFramepos;
int nFrames = nBufferSize - nInitialSilence;
if ( nFrames < 0 ) {
int noteStartInFramesNoHumanize = ( int )pNote->get_position() * audio_output->m_transport.m_nTickSize;
if ( noteStartInFramesNoHumanize > ( int )( nFramepos + nBufferSize ) ) {
// this note is not valid. it's in the future...let's skip it....
ERRORLOG( QString( "Note pos in the future?? Current frames: %1, note frame pos: %2" ).arg( nFramepos ).arg(noteStartInFramesNoHumanize ) );
//pNote->dumpInfo();
return 1;
}
// delay note execution
//INFOLOG( "Delaying note execution. noteStartInFrames: " + to_string( noteStartInFrames ) + ", nFramePos: " + to_string( nFramepos ) );
return 0;
}
}
float cost_L = 1.0f;
float cost_R = 1.0f;
float cost_track_L = 1.0f;
float cost_track_R = 1.0f;
if ( pInstr->is_muted() || pSong->__is_muted ) { // is instrument muted?
cost_L = 0.0;
cost_R = 0.0;
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = 0.0;
cost_track_R = 0.0;
}
} else { // Precompute some values...
cost_L = cost_L * pNote->get_velocity(); // note velocity
cost_L = cost_L * pNote->get_pan_l(); // note pan
cost_L = cost_L * fLayerGain; // layer gain
cost_L = cost_L * pInstr->get_pan_l(); // instrument pan
cost_L = cost_L * pInstr->get_gain(); // instrument gain
cost_L = cost_L * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = cost_L * 2;
}
cost_L = cost_L * pSong->get_volume(); // song volume
cost_L = cost_L * 2; // max pan is 0.5
cost_R = cost_R * pNote->get_velocity(); // note velocity
cost_R = cost_R * pNote->get_pan_r(); // note pan
cost_R = cost_R * fLayerGain; // layer gain
cost_R = cost_R * pInstr->get_pan_r(); // instrument pan
cost_R = cost_R * pInstr->get_gain(); // instrument gain
cost_R = cost_R * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_R = cost_R * 2;
}
cost_R = cost_R * pSong->get_volume(); // song pan
cost_R = cost_R * 2; // max pan is 0.5
}
// direct track outputs only use velocity
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 1 ) {
cost_track_L = cost_track_L * pNote->get_velocity();
cost_track_L = cost_track_L * fLayerGain;
cost_track_R = cost_track_L;
}
// Se non devo fare resample (drumkit) posso evitare di utilizzare i float e gestire il tutto in
// maniera ottimizzata
// constant^12 = 2, so constant = 2^(1/12) = 1.059463.
// float nStep = 1.0;1.0594630943593
float fTotalPitch = pNote->get_total_pitch() + fLayerPitch;
//_INFOLOG( "total pitch: " + to_string( fTotalPitch ) );
if( ( int )pNote->get_sample_position() == 0 )
{
if( Hydrogen::get_instance()->getMidiOutput() != NULL ){
Hydrogen::get_instance()->getMidiOutput()->handleQueueNote( pNote );
}
}
if ( fTotalPitch == 0.0 && pSample->get_sample_rate() == audio_output->getSampleRate() ) { // NO RESAMPLE
return __render_note_no_resample( pSample, pNote, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, pSong );
} else { // RESAMPLE
return __render_note_resample( pSample, pNote, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, fLayerPitch, pSong );
}
}
bool Sampler::processPlaybackTrack(int nBufferSize)
{
Hydrogen* pEngine = Hydrogen::get_instance();
AudioOutput* pAudioOutput = Hydrogen::get_instance()->getAudioOutput();
Song* pSong = pEngine->getSong();
if( !pSong->get_playback_track_enabled()
|| pEngine->getState() != STATE_PLAYING
|| pSong->get_mode() != Song::SONG_MODE)
{
return false;
}
InstrumentComponent *pCompo = __playback_instrument->get_components()->front();
Sample *pSample = pCompo->get_layer(0)->get_sample();
float fVal_L;
float fVal_R;
float *pSample_data_L = pSample->get_data_l();
float *pSample_data_R = pSample->get_data_r();
float fInstrPeak_L = __playback_instrument->get_peak_l(); // this value will be reset to 0 by the mixer..
float fInstrPeak_R = __playback_instrument->get_peak_r(); // this value will be reset to 0 by the mixer..
assert(pSample);
int nAvail_bytes = 0;
int nInitialBufferPos = 0;
if(pSample->get_sample_rate() == pAudioOutput->getSampleRate()){
//No resampling
__playBackSamplePosition = pAudioOutput->m_transport.m_nFrames;
nAvail_bytes = pSample->get_frames() - ( int )__playBackSamplePosition;
if ( nAvail_bytes > nBufferSize ) {
nAvail_bytes = nBufferSize;
}
int nInitialSamplePos = ( int ) __playBackSamplePosition;
int nSamplePos = nInitialSamplePos;
int nTimes = nInitialBufferPos + nAvail_bytes;
if(__playBackSamplePosition > pSample->get_frames()){
//playback track has ended..
return true;
}
for ( int nBufferPos = nInitialBufferPos; nBufferPos < nTimes; ++nBufferPos ) {
fVal_L = pSample_data_L[ nSamplePos ];
fVal_R = pSample_data_R[ nSamplePos ];
fVal_L = fVal_L * 1.0f * pSong->get_playback_track_volume(); //costr
fVal_R = fVal_R * 1.0f * pSong->get_playback_track_volume(); //cost l
//pDrumCompo->set_outs( nBufferPos, fVal_L, fVal_R );
// to main mix
if ( fVal_L > fInstrPeak_L ) {
fInstrPeak_L = fVal_L;
}
if ( fVal_R > fInstrPeak_R ) {
fInstrPeak_R = fVal_R;
}
__main_out_L[nBufferPos] += fVal_L;
__main_out_R[nBufferPos] += fVal_R;
++nSamplePos;
}
} else {
//Perform resampling
double fSamplePos = 0;
int nSampleFrames = pSample->get_frames();
float fStep = 1.0594630943593;
fStep *= ( float )pSample->get_sample_rate() / pAudioOutput->getSampleRate(); // Adjust for audio driver sample rate
if(pAudioOutput->m_transport.m_nFrames == 0){
fSamplePos = 0;
} else {
fSamplePos = ( (pAudioOutput->m_transport.m_nFrames/nBufferSize) * (nBufferSize * fStep));
}
nAvail_bytes = ( int )( ( float )( pSample->get_frames() - fSamplePos ) / fStep );
if ( nAvail_bytes > nBufferSize ) {
nAvail_bytes = nBufferSize;
}
int nTimes = nInitialBufferPos + nAvail_bytes;
for ( int nBufferPos = nInitialBufferPos; nBufferPos < nTimes; ++nBufferPos ) {
int nSamplePos = ( int ) fSamplePos;
double fDiff = fSamplePos - nSamplePos;
if ( ( nSamplePos + 1 ) >= nSampleFrames ) {
//we reach the last audioframe.
//set this last frame to zero do nothin wrong.
fVal_L = 0.0;
fVal_R = 0.0;
} else {
// some interpolation methods need 4 frames data.
float last_l;
float last_r;
if ( ( nSamplePos + 2 ) >= nSampleFrames ) {
last_l = 0.0;
last_r = 0.0;
} else {
last_l = pSample_data_L[nSamplePos + 2];
last_r = pSample_data_R[nSamplePos + 2];
}
switch( __interpolateMode ){
case LINEAR:
fVal_L = pSample_data_L[nSamplePos] * (1 - fDiff ) + pSample_data_L[nSamplePos + 1] * fDiff;
fVal_R = pSample_data_R[nSamplePos] * (1 - fDiff ) + pSample_data_R[nSamplePos + 1] * fDiff;
break;
case COSINE:
fVal_L = cosine_Interpolate( pSample_data_L[nSamplePos], pSample_data_L[nSamplePos + 1], fDiff);
fVal_R = cosine_Interpolate( pSample_data_R[nSamplePos], pSample_data_R[nSamplePos + 1], fDiff);
break;
case THIRD:
fVal_L = third_Interpolate( pSample_data_L[ nSamplePos -1], pSample_data_L[nSamplePos], pSample_data_L[nSamplePos + 1], last_l, fDiff);
fVal_R = third_Interpolate( pSample_data_R[ nSamplePos -1], pSample_data_R[nSamplePos], pSample_data_R[nSamplePos + 1], last_r, fDiff);
break;
case CUBIC:
fVal_L = cubic_Interpolate( pSample_data_L[ nSamplePos -1], pSample_data_L[nSamplePos], pSample_data_L[nSamplePos + 1], last_l, fDiff);
fVal_R = cubic_Interpolate( pSample_data_R[ nSamplePos -1], pSample_data_R[nSamplePos], pSample_data_R[nSamplePos + 1], last_r, fDiff);
break;
case HERMITE:
fVal_L = hermite_Interpolate( pSample_data_L[ nSamplePos -1], pSample_data_L[nSamplePos], pSample_data_L[nSamplePos + 1], last_l, fDiff);
fVal_R = hermite_Interpolate( pSample_data_R[ nSamplePos -1], pSample_data_R[nSamplePos], pSample_data_R[nSamplePos + 1], last_r, fDiff);
break;
}
}
if ( fVal_L > fInstrPeak_L ) {
fInstrPeak_L = fVal_L;
}
if ( fVal_R > fInstrPeak_R ) {
fInstrPeak_R = fVal_R;
}
__main_out_L[nBufferPos] += fVal_L;
__main_out_R[nBufferPos] += fVal_R;
fSamplePos += fStep;
} //for
}
__playback_instrument->set_peak_l( fInstrPeak_L );
__playback_instrument->set_peak_r( fInstrPeak_R );
return true;
}
/// Render a note
/// Return false: the note is not ended
/// Return true: the note is ended
bool Sampler::__render_note( Note* pNote, unsigned nBufferSize, Song* pSong )
{
//infoLog( "[renderNote] instr: " + pNote->getInstrument()->m_sName );
assert( pSong );
unsigned int nFramepos;
Hydrogen* pEngine = Hydrogen::get_instance();
AudioOutput* audio_output = pEngine->getAudioOutput();
if ( pEngine->getState() == STATE_PLAYING ) {
nFramepos = audio_output->m_transport.m_nFrames;
} else {
// use this to support realtime events when not playing
nFramepos = pEngine->getRealtimeFrames();
}
Instrument *pInstr = pNote->get_instrument();
if ( !pInstr ) {
ERRORLOG( "NULL instrument" );
return 1;
}
bool nReturnValues [pInstr->get_components()->size()];
for(int i = 0; i < pInstr->get_components()->size(); i++){
nReturnValues[i] = false;
}
int nReturnValueIndex = 0;
int nAlreadySelectedLayer = -1;
for (std::vector<InstrumentComponent*>::iterator it = pInstr->get_components()->begin() ; it !=pInstr->get_components()->end(); ++it) {
nReturnValues[nReturnValueIndex] = false;
InstrumentComponent *pCompo = *it;
DrumkitComponent* pMainCompo = pEngine->getSong()->get_component( pCompo->get_drumkit_componentID() );
if( pNote->get_specific_compo_id() != -1 && pNote->get_specific_compo_id() != pCompo->get_drumkit_componentID() )
continue;
if( pInstr->is_preview_instrument()
|| pInstr->is_metronome_instrument()){
pMainCompo = pEngine->getSong()->get_components()->front();
} else {
pMainCompo = pEngine->getSong()->get_component( pCompo->get_drumkit_componentID() );
}
assert(pMainCompo);
float fLayerGain = 1.0;
float fLayerPitch = 0.0;
// scelgo il sample da usare in base alla velocity
Sample *pSample = nullptr;
SelectedLayerInfo *pSelectedLayer = pNote->get_layer_selected( pCompo->get_drumkit_componentID() );
if ( !pSelectedLayer ) {
QString dummy = QString( "NULL Layer Information for instrument %1. Component: %2" ).arg( pInstr->get_name() ).arg( pCompo->get_drumkit_componentID() );
WARNINGLOG( dummy );
nReturnValues[nReturnValueIndex] = true;
continue;
}
if( pSelectedLayer->SelectedLayer != -1 ) {
InstrumentLayer *pLayer = pCompo->get_layer( pSelectedLayer->SelectedLayer );
if( pLayer )
{
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
else {
switch ( pInstr->sample_selection_alg() ) {
case Instrument::VELOCITY:
for ( unsigned nLayer = 0; nLayer < __maxLayers; ++nLayer ) {
InstrumentLayer *pLayer = pCompo->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
pSelectedLayer->SelectedLayer = nLayer;
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
break;
}
}
break;
case Instrument::RANDOM:
if( nAlreadySelectedLayer != -1 ) {
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
if ( pLayer != NULL ) {
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
if( pSample == NULL ) {
int __possibleIndex[ __maxLayers ];
int __poundSamples = 0;
for ( unsigned nLayer = 0; nLayer < __maxLayers; ++nLayer ) {
InstrumentLayer *pLayer = pCompo->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
__possibleIndex[__poundSamples] = nLayer;
__poundSamples++;
}
}
if( __poundSamples > 0 ) {
nAlreadySelectedLayer = __possibleIndex[rand() % __poundSamples];
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
break;
case Instrument::ROUND_ROBIN:
if( nAlreadySelectedLayer != -1 ) {
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
if ( pLayer != NULL ) {
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
if( !pSample ) {
int __possibleIndex[ __maxLayers ];
int __foundSamples = 0;
float __roundRobinID;
for ( unsigned nLayer = 0; nLayer < __maxLayers; ++nLayer ) {
InstrumentLayer *pLayer = pCompo->get_layer( nLayer );
if ( pLayer == NULL ) continue;
if ( ( pNote->get_velocity() >= pLayer->get_start_velocity() ) && ( pNote->get_velocity() <= pLayer->get_end_velocity() ) ) {
__possibleIndex[__foundSamples] = nLayer;
__roundRobinID = pLayer->get_start_velocity();
__foundSamples++;
}
}
if( __foundSamples > 0 ) {
__roundRobinID = pInstr->get_id() * 10 + __roundRobinID;
int p_indexToUse = pSong->get_latest_round_robin(__roundRobinID)+1;
if( p_indexToUse > __foundSamples - 1)
p_indexToUse = 0;
pSong->set_latest_round_robin(__roundRobinID, p_indexToUse);
nAlreadySelectedLayer = __possibleIndex[p_indexToUse];
pSelectedLayer->SelectedLayer = nAlreadySelectedLayer;
InstrumentLayer *pLayer = pCompo->get_layer( nAlreadySelectedLayer );
pSample = pLayer->get_sample();
fLayerGain = pLayer->get_gain();
fLayerPitch = pLayer->get_pitch();
}
}
break;
}
}
if ( !pSample ) {
QString dummy = QString( "NULL sample for instrument %1. Note velocity: %2" ).arg( pInstr->get_name() ).arg( pNote->get_velocity() );
WARNINGLOG( dummy );
nReturnValues[nReturnValueIndex] = true;
continue;
}
if ( pSelectedLayer->SamplePosition >= pSample->get_frames() ) {
WARNINGLOG( "sample position out of bounds. The layer has been resized during note play?" );
nReturnValues[nReturnValueIndex] = true;
continue;
}
int noteStartInFrames = ( int ) ( pNote->get_position() * audio_output->m_transport.m_nTickSize ) + pNote->get_humanize_delay();
int nInitialSilence = 0;
if ( noteStartInFrames > ( int ) nFramepos ) { // scrivo silenzio prima dell'inizio della nota
nInitialSilence = noteStartInFrames - nFramepos;
int nFrames = nBufferSize - nInitialSilence;
if ( nFrames < 0 ) {
int noteStartInFramesNoHumanize = ( int )pNote->get_position() * audio_output->m_transport.m_nTickSize;
if ( noteStartInFramesNoHumanize > ( int )( nFramepos + nBufferSize ) ) {
// this note is not valid. it's in the future...let's skip it....
ERRORLOG( QString( "Note pos in the future?? Current frames: %1, note frame pos: %2" ).arg( nFramepos ).arg(noteStartInFramesNoHumanize ) );
//pNote->dumpInfo();
nReturnValues[nReturnValueIndex] = true;
continue;
}
// delay note execution
//INFOLOG( "Delaying note execution. noteStartInFrames: " + to_string( noteStartInFrames ) + ", nFramePos: " + to_string( nFramepos ) );
//return 0;
continue;
}
}
float cost_L = 1.0f;
float cost_R = 1.0f;
float cost_track_L = 1.0f;
float cost_track_R = 1.0f;
assert(pMainCompo);
bool isMutedForExport = (pEngine->getIsExportSessionActive() && !pInstr->is_currently_exported());
/*
* Is instrument muted?
*
* This can be the case either if the song, instrument or component is muted or if we're in an
* export session and we're doing per-instruments exports, but this instrument is not currently
* beeing exported.
*/
if ( isMutedForExport || pInstr->is_muted() || pSong->__is_muted || pMainCompo->is_muted() ) {
cost_L = 0.0;
cost_R = 0.0;
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = 0.0;
cost_track_R = 0.0;
}
} else { // Precompute some values...
if ( pInstr->get_apply_velocity() ) {
cost_L = cost_L * pNote->get_velocity(); // note velocity
cost_R = cost_R * pNote->get_velocity(); // note velocity
}
cost_L = cost_L * pNote->get_pan_l(); // note pan
cost_L = cost_L * fLayerGain; // layer gain
cost_L = cost_L * pInstr->get_pan_l(); // instrument pan
cost_L = cost_L * pInstr->get_gain(); // instrument gain
cost_L = cost_L * pCompo->get_gain(); // Component gain
cost_L = cost_L * pMainCompo->get_volume(); // Component volument
cost_L = cost_L * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_L = cost_L * 2;
}
cost_L = cost_L * pSong->get_volume(); // song volume
cost_L = cost_L * 2; // max pan is 0.5
cost_R = cost_R * pNote->get_pan_r(); // note pan
cost_R = cost_R * fLayerGain; // layer gain
cost_R = cost_R * pInstr->get_pan_r(); // instrument pan
cost_R = cost_R * pInstr->get_gain(); // instrument gain
cost_R = cost_R * pCompo->get_gain(); // Component gain
cost_R = cost_R * pMainCompo->get_volume(); // Component volument
cost_R = cost_R * pInstr->get_volume(); // instrument volume
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 0 ) {
// Post-Fader
cost_track_R = cost_R * 2;
}
cost_R = cost_R * pSong->get_volume(); // song pan
cost_R = cost_R * 2; // max pan is 0.5
}
// direct track outputs only use velocity
if ( Preferences::get_instance()->m_nJackTrackOutputMode == 1 ) {
cost_track_L = cost_track_L * pNote->get_velocity();
cost_track_L = cost_track_L * fLayerGain;
cost_track_R = cost_track_L;
}
// Se non devo fare resample (drumkit) posso evitare di utilizzare i float e gestire il tutto in
// maniera ottimizzata
// constant^12 = 2, so constant = 2^(1/12) = 1.059463.
// float nStep = 1.0;1.0594630943593
float fTotalPitch = pNote->get_total_pitch() + fLayerPitch;
//_INFOLOG( "total pitch: " + to_string( fTotalPitch ) );
if( ( int )pSelectedLayer->SamplePosition == 0 )
{
if( Hydrogen::get_instance()->getMidiOutput() != NULL ){
Hydrogen::get_instance()->getMidiOutput()->handleQueueNote( pNote );
}
}
if ( fTotalPitch == 0.0 && pSample->get_sample_rate() == audio_output->getSampleRate() ) // NO RESAMPLE
nReturnValues[nReturnValueIndex] = __render_note_no_resample( pSample, pNote, pSelectedLayer, pCompo, pMainCompo, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, pSong );
else // RESAMPLE
nReturnValues[nReturnValueIndex] = __render_note_resample( pSample, pNote, pSelectedLayer, pCompo, pMainCompo, nBufferSize, nInitialSilence, cost_L, cost_R, cost_track_L, cost_track_R, fLayerPitch, pSong );
nReturnValueIndex++;
}
for ( unsigned i = 0 ; i < pInstr->get_components()->size() ; i++ )
if ( !nReturnValues[i] ) return false;
return true;
}
void PlaylistDialog::on_m_pPlaylistTree_itemDoubleClicked ()
{
QTreeWidgetItem* m_pPlaylistItem = m_pPlaylistTree->currentItem();
if ( m_pPlaylistItem == NULL ){
QMessageBox::information ( this, "Hydrogen", trUtf8 ( "No Song selected!" ) );
return;
}
QString selected;
selected = m_pPlaylistItem->text ( 0 );
QTreeWidget* m_pPlaylist = m_pPlaylistTree;
int index = m_pPlaylist->indexOfTopLevelItem ( m_pPlaylistItem );
Playlist::get_instance()->setSelectedSongNr( index );
Playlist::get_instance()->setActiveSongNumber( index );
HydrogenApp *pH2App = HydrogenApp::get_instance();
Hydrogen *pEngine = Hydrogen::get_instance();
if ( pEngine->getState() == STATE_PLAYING ){
pEngine->sequencer_stop();
}
m_pPlayBtn->setPressed(false);
Timeline* pTimeline = pEngine->getTimeline();
pTimeline->m_timelinetagvector.clear();
Song *pSong = Song::load ( selected );
if ( pSong == NULL ){
QMessageBox::information ( this, "Hydrogen", trUtf8 ( "Error loading song." ) );
return;
}
pH2App->setSong ( pSong );
pEngine->setSelectedPatternNumber ( 0 );
HydrogenApp::get_instance()->getSongEditorPanel()->updatePositionRuler();
pH2App->setStatusBarMessage( trUtf8( "Playlist: set song no. %1" ).arg( index +1 ), 5000 );
HydrogenApp::get_instance()->getInstrumentRack()->getSoundLibraryPanel()->update_background_color();
EventQueue::get_instance()->push_event( EVENT_METRONOME, 3 );
///exec script
///this is very very simple and only an experiment
#ifdef WIN32
//I know nothing about windows scripts -wolke-
return;
#else
QString execscript;
selected = m_pPlaylistItem->text ( 1 );
bool execcheckbox = m_pPlaylistItem->checkState ( 2 );
if( execcheckbox == false){
//QMessageBox::information ( this, "Hydrogen", trUtf8 ( "No Script selected!" ));
return;
}
if( execscript == "Script not used"){
//QMessageBox::information ( this, "Hydrogen", trUtf8 ( "Script not in use!" ));
return;
}
char *file;
file = new char[ selected.length() + 1 ];
strcpy( file , selected.toAscii() );
int ret = std::system( file );
delete [] file;
return;
#endif
}
