InstrumentList.cpp

Go to the documentation of this file.

/*
 * Hydrogen
 * Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
 * Copyright(c) 2008-2025 The hydrogen development team [hydrogen-devel@lists.sourceforge.net]
 *
 * http://www.hydrogen-music.org
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY, without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see https://www.gnu.org/licenses
 *
 */
 
#include <core/Basics/DrumkitComponent.h>
#include <core/Basics/InstrumentComponent.h>
#include <core/Basics/InstrumentLayer.h>
#include <core/Basics/InstrumentList.h>
#include <core/Basics/Instrument.h>
#include <core/Basics/Sample.h>
 
#include <core/Helpers/Xml.h>
#include <core/IO/MidiCommon.h>
#include <core/License.h>
 
#include <set>
 
namespace H2Core
{
 
InstrumentList::InstrumentList()
{
}
 
InstrumentList::InstrumentList( std::shared_ptr<InstrumentList> other ) : Object( *other )
{
        assert( other );
        assert( __instruments.size() == 0 );
        for ( int i=0; i<other->size(); i++ ) {
                ( *this ) << ( std::make_shared<Instrument>( ( *other )[i] ) );
        }
}
 
InstrumentList::~InstrumentList()
{
}
 
void InstrumentList::load_samples( float fBpm )
{
        for( int i=0; i<__instruments.size(); i++ ) {
                __instruments[i]->load_samples( fBpm );
        }
}
 
void InstrumentList::unload_samples()
{
        for( int i=0; i<__instruments.size(); i++ ) {
                __instruments[i]->unload_samples();
        }
}
 
std::shared_ptr<InstrumentList> InstrumentList::load_from( XMLNode* pNode,
                                                                                                                   const QString& sDrumkitPath,
                                                                                                                   const QString& sDrumkitName,
                                                                                                                   const License& license,
                                                                                                                   bool* pLegacyFormatEncountered,
                                                                                                                   bool bSilent )
{
        XMLNode instrumentListNode = pNode->firstChildElement( "instrumentList" );
        if ( instrumentListNode.isNull() ) {
                ERRORLOG( "'instrumentList' node not found. Unable to load instrument list." );
                return nullptr;
        }
 
        auto pInstrumentList = std::make_shared<InstrumentList>();
        XMLNode instrumentNode = instrumentListNode.firstChildElement( "instrument" );
        int nCount = 0;
        while ( !instrumentNode.isNull() ) {
                nCount++;
                if ( nCount > MAX_INSTRUMENTS ) {
                        ERRORLOG( QString( "instrument nCount >= %1 (MAX_INSTRUMENTS), stop reading instruments" )
                                          .arg( MAX_INSTRUMENTS ) );
                        break;
                }
 
                auto pInstrument = Instrument::load_from(
                        &instrumentNode, sDrumkitPath, sDrumkitName, license,
                        pLegacyFormatEncountered, bSilent );
                if ( pInstrument != nullptr ) {
                        ( *pInstrumentList ) << pInstrument;
                }
                else {
                        ERRORLOG( QString( "Unable to load instrument [%1]. The drumkit is corrupted. Skipping instrument" )
                                          .arg( nCount ) );
                        nCount--;
                }
                instrumentNode = instrumentNode.nextSiblingElement( "instrument" );
        }
 
        if ( nCount == 0 ) {
                ERRORLOG( "Newly created instrument list does not contain any instruments. Aborting." );
                return nullptr;
        }
        
        return pInstrumentList;
}
 
void InstrumentList::save_to( XMLNode* node, int component_id, bool bRecentVersion, bool bFull )
{
        XMLNode instruments_node = node->createNode( "instrumentList" );
        for ( const auto& pInstrument : __instruments ) {
                assert( pInstrument );
                assert( pInstrument->get_adsr() );
                if ( pInstrument != nullptr && pInstrument->get_adsr() != nullptr ) {
                        pInstrument->save_to( &instruments_node, component_id, bRecentVersion, bFull );
                }
        }
}
 
void InstrumentList::operator<<( std::shared_ptr<Instrument> instrument )
{
        // do nothing if already in __instruments
        for( int i=0; i<__instruments.size(); i++ ) {
                if( __instruments[i]==instrument ) return;
        }
        __instruments.push_back( instrument );
}
        
bool InstrumentList::operator==( std::shared_ptr<InstrumentList> pOther ) const {
        if ( pOther != nullptr && size() == pOther->size() ) {
                for ( int ii = 0; ii < size(); ++ii ) {
                        if ( get( ii ).get() != pOther->get( ii ).get() ) {
                                return false;
                        }
                }
 
                return true;
        }
 
        return false;
}
 
bool InstrumentList::operator!=( std::shared_ptr<InstrumentList> pOther ) const {
        if ( pOther != nullptr && size() == pOther->size() ) {
                for ( int ii = 0; ii < size(); ++ii ) {
                        if ( get( ii ).get() != pOther->get( ii ).get() ) {
                                return true;
                        }
                }
 
                return false;
        }
 
        return true;
}
 
void InstrumentList::add( std::shared_ptr<Instrument> instrument )
{
        // do nothing if already in __instruments
        for( int i=0; i<__instruments.size(); i++ ) {
                if( __instruments[i]==instrument ) return;
        }
        __instruments.push_back( instrument );
}
 
void InstrumentList::insert( int idx, std::shared_ptr<Instrument> instrument )
{
        // do nothing if already in __instruments
        for( int i=0; i<__instruments.size(); i++ ) {
                if( __instruments[i]==instrument ) return;
        }
        __instruments.insert( __instruments.begin() + idx, instrument );
}
 
std::shared_ptr<Instrument> InstrumentList::operator[]( int idx )
{
        if ( idx < 0 || idx >= __instruments.size() ) {
                ERRORLOG( QString( "idx %1 out of [0;%2]" ).arg( idx ).arg( size() ) );
                return nullptr;
        }
        assert( idx >= 0 && idx < __instruments.size() );
        return __instruments[idx];
}
 
bool InstrumentList::is_valid_index( int idx ) const
{
        bool is_valid_index = true;
        
        if ( idx < 0 || idx >= __instruments.size() ) {
                is_valid_index = false;
        }
        
        return is_valid_index;
}
 
std::shared_ptr<Instrument> InstrumentList::get( int idx ) const
{
        if ( ! is_valid_index( idx ) ) {
                ERRORLOG( QString( "idx %1 out of [0;%2]" ).arg( idx ).arg( size() ) );
                return nullptr;
        }
        assert( idx >= 0 && idx < __instruments.size() );
        return __instruments.at( idx );
}
 
int InstrumentList::index( std::shared_ptr<Instrument> instr )
{
        for( int i=0; i<__instruments.size(); i++ ) {
                if ( __instruments[i]==instr ) return i;
        }
        return -1;
}
 
std::shared_ptr<Instrument>  InstrumentList::find( const int id )
{
        for( int i=0; i<__instruments.size(); i++ ) {
                if ( __instruments[i]->get_id()==id ) return __instruments[i];
        }
        return nullptr;
}
 
std::shared_ptr<Instrument>  InstrumentList::find( const QString& name )
{
        for( int i=0; i<__instruments.size(); i++ ) {
                if ( __instruments[i]->get_name()==name ) return __instruments[i];
        }
        return nullptr;
}
 
std::shared_ptr<Instrument>  InstrumentList::findMidiNote( const int note )
{
        for( int i=0; i<__instruments.size(); i++ ) {
                if ( __instruments[i]->get_midi_out_note()==note ) return __instruments[i];
        }
        return nullptr;
}
 
std::shared_ptr<Instrument> InstrumentList::del( int idx )
{
        assert( idx >= 0 && idx < __instruments.size() );
        auto instrument = __instruments[idx];
        __instruments.erase( __instruments.begin() + idx );
        return instrument;
}
 
std::shared_ptr<Instrument> InstrumentList::del( std::shared_ptr<Instrument> instrument )
{
        for( int i=0; i<__instruments.size(); i++ ) {
                if( __instruments[i]==instrument ) {
                        __instruments.erase( __instruments.begin() + i );
                        return instrument;
                }
        }
        return nullptr;
}
 
void InstrumentList::swap( int idx_a, int idx_b )
{
        assert( idx_a >= 0 && idx_a < __instruments.size() );
        assert( idx_b >= 0 && idx_b < __instruments.size() );
        if( idx_a == idx_b ) return;
        //DEBUGLOG(QString("===>> SWAP  %1 %2").arg(idx_a).arg(idx_b) );
        auto tmp = __instruments[idx_a];
        __instruments[idx_a] = __instruments[idx_b];
        __instruments[idx_b] = tmp;
}
 
void InstrumentList::move( int idx_a, int idx_b )
{
        assert( idx_a >= 0 && idx_a < __instruments.size() );
        assert( idx_b >= 0 && idx_b < __instruments.size() );
        if( idx_a == idx_b ) return;
        //DEBUGLOG(QString("===>> MOVE  %1 %2").arg(idx_a).arg(idx_b) );
        auto tmp = __instruments[idx_a];
        __instruments.erase( __instruments.begin() + idx_a );
        __instruments.insert( __instruments.begin() + idx_b, tmp );
}
 
std::vector<std::shared_ptr<InstrumentList::Content>> InstrumentList::summarizeContent( const std::shared_ptr<std::vector<std::shared_ptr<DrumkitComponent>>> pDrumkitComponents ) const {
        std::vector<std::shared_ptr<InstrumentList::Content>> results;
 
        for ( const auto& ppInstrument : __instruments ) {
                if ( ppInstrument != nullptr ) {
                        for ( const auto& ppInstrumentComponent : *ppInstrument->get_components() ) {
                                if ( ppInstrumentComponent != nullptr ) {
                                        for ( const auto& ppInstrumentLayer : *ppInstrumentComponent ) {
                                                if ( ppInstrumentLayer != nullptr ) {
                                                        auto pSample = ppInstrumentLayer->get_sample();
                                                        if ( pSample != nullptr ) {
                                                                // Map component ID to component
                                                                // name.
                                                                bool bFound = false;
                                                                QString sComponentName;
                                                                for ( const auto& ppDrumkitComponent : *pDrumkitComponents ) {
                                                                        if ( ppInstrumentComponent->get_drumkit_componentID() ==
                                                                                 ppDrumkitComponent->get_id() ) {
                                                                                bFound = true;
                                                                                sComponentName = ppDrumkitComponent->get_name();
                                                                                break;
                                                                        }
                                                                }
 
                                                                if ( ! bFound ) {
                                                                        sComponentName = pDrumkitComponents->front()->get_name();
                                                                }
 
                                                                results.push_back( std::make_shared<Content>(
                                                                        ppInstrument->get_name(), // m_sInstrumentName
                                                                        sComponentName, // m_sComponentName
                                                                        pSample->get_filename(), // m_sSampleName
                                                                        pSample->get_filepath(), // m_sFullSamplePath
                                                                        pSample->getLicense() // m_license
                                                                    ) );
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }
 
        return results;
}
 
void InstrumentList::fix_issue_307()
{
        if ( has_all_midi_notes_same() ) {
                WARNINGLOG( "Same MIDI note assigned to every instrument. Assigning default values." );
                set_default_midi_out_notes();
        }
}
 
bool InstrumentList::has_all_midi_notes_same() const
{
        if (__instruments.size() < 2) {
                return false;
        }
 
        std::set<int> notes;
        for( int i=0; i<__instruments.size(); i++ ) {
                auto instr = __instruments[i];
                notes.insert( instr->get_midi_out_note() );
        }
        return notes.size() == 1;
}
 
void InstrumentList::set_default_midi_out_notes()
{
        for( int i=0; i<__instruments.size(); i++ ) {
                __instruments[i]->set_midi_out_note( i + MidiMessage::instrumentOffset );
        }
}
 
QString InstrumentList::toQString( const QString& sPrefix, bool bShort ) const {
        QString s = Base::sPrintIndention;
        QString sOutput;
        if ( ! bShort ) {
                sOutput = QString( "%1[InstrumentList]\n" ).arg( sPrefix );
                for ( auto ii : __instruments ) {
                        if ( ii != nullptr ) {
                                sOutput.append( QString( "%1" ).arg( ii->toQString( sPrefix + s, bShort ) ) );
                        }
                }
        } else {
                sOutput = QString( "[InstrumentList] " );
                for ( auto ii : __instruments ) {
                        if ( ii != nullptr ) {
                                sOutput.append( QString( "(%1: %2) " ).arg( ii->get_id() )
                                                                .arg( ii->get_name() ) );
                        }
                }
        }
        
        return sOutput;
}
 
 
std::vector<std::shared_ptr<Instrument>>::iterator InstrumentList::begin() {
        return __instruments.begin();
}
 
std::vector<std::shared_ptr<Instrument>>::iterator InstrumentList::end() {
        return __instruments.end();
}
 
QString InstrumentList::Content::toQString( const QString& sPrefix, bool bShort ) const {
        
        QString s = Base::sPrintIndention;
        QString sOutput;
        if ( ! bShort ) {
                sOutput = QString( "\n" ).arg( sPrefix )
                        .append( QString( "%1%2m_sInstrumentName: %3\n" ).arg( sPrefix ).arg( s ).arg( m_sInstrumentName ) )
                        .append( QString( "%1%2m_sComponentName: %3\n" ).arg( sPrefix ).arg( s ).arg( m_sComponentName ) )
                        .append( QString( "%1%2m_sSampleName: %3\n" ).arg( sPrefix ).arg( s ).arg( m_sSampleName ) )
                        .append( QString( "%1%2m_sFullSamplePath: %3\n" ).arg( sPrefix ).arg( s ).arg( m_sFullSamplePath ) )
                        .append( QString( "%1%2m_license: %3\n" ).arg( m_license.toQString( sPrefix + s, bShort ) ) );
        } else {
                sOutput = QString( "m_sInstrumentName: %1\n" ).arg( m_sInstrumentName )
                        .append( QString( ", m_sComponentName: %1\n" ).arg( m_sComponentName ) )
                        .append( QString( ", m_sSampleName: %1\n" ).arg( m_sSampleName ) )
                        .append( QString( ", m_sFullSamplePath: %1\n" ).arg( m_sFullSamplePath ) )
                        .append( QString( ", m_license: %1\n" ).arg( m_license.toQString( "", bShort ) ) );
        }
 
        return sOutput;
}
 
 
bool InstrumentList::isAnyInstrumentSoloed()
{
        for ( auto &pInstrument : __instruments ) {
                if ( pInstrument->is_soloed() ) {
                        return true;
                }
        }
        return false;
}
 
 
};
 
/* vim: set softtabstop=4 noexpandtab: */