1446 lines
50 KiB
C++
1446 lines
50 KiB
C++
#include "midi_container.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include <algorithm>
|
|
|
|
midi_event::midi_event( const midi_event & p_in )
|
|
{
|
|
m_timestamp = p_in.m_timestamp;
|
|
m_channel = p_in.m_channel;
|
|
m_type = p_in.m_type;
|
|
m_data_count = p_in.m_data_count;
|
|
memcpy( m_data, p_in.m_data, m_data_count );
|
|
m_ext_data = p_in.m_ext_data;
|
|
}
|
|
|
|
midi_event::midi_event( unsigned long p_timestamp, event_type p_type, unsigned p_channel, const uint8_t * p_data, std::size_t p_data_count )
|
|
{
|
|
m_timestamp = p_timestamp;
|
|
m_type = p_type;
|
|
m_channel = p_channel;
|
|
if ( p_data_count <= max_static_data_count )
|
|
{
|
|
m_data_count = p_data_count;
|
|
memcpy( m_data, p_data, p_data_count );
|
|
}
|
|
else
|
|
{
|
|
m_data_count = max_static_data_count;
|
|
memcpy( m_data, p_data, max_static_data_count );
|
|
m_ext_data.assign( p_data + max_static_data_count, p_data + p_data_count );
|
|
}
|
|
}
|
|
|
|
unsigned long midi_event::get_data_count() const
|
|
{
|
|
return m_data_count + m_ext_data.size();
|
|
}
|
|
|
|
void midi_event::copy_data( uint8_t * p_out, unsigned long p_offset, unsigned long p_count ) const
|
|
{
|
|
unsigned long max_count = m_data_count + m_ext_data.size() - p_offset;
|
|
p_count = std::min( p_count, max_count );
|
|
if ( p_offset < max_static_data_count )
|
|
{
|
|
unsigned long _max_count = max_static_data_count - p_offset;
|
|
unsigned long count = std::min( _max_count, p_count );
|
|
memcpy( p_out, m_data + p_offset, count );
|
|
p_offset -= count;
|
|
p_count -= count;
|
|
p_out += count;
|
|
}
|
|
if ( p_count ) memcpy( p_out, &m_ext_data[0], p_count );
|
|
}
|
|
|
|
midi_track::midi_track(const midi_track & p_in)
|
|
{
|
|
m_events = p_in.m_events;
|
|
}
|
|
|
|
void midi_track::add_event( const midi_event & p_event )
|
|
{
|
|
auto it = m_events.end();
|
|
|
|
if ( m_events.size() )
|
|
{
|
|
midi_event & event = *(it - 1);
|
|
if ( event.m_type == midi_event::extended && event.get_data_count() >= 2 &&
|
|
event.m_data[ 0 ] == 0xFF && event.m_data[ 1 ] == 0x2F )
|
|
{
|
|
--it;
|
|
if ( event.m_timestamp < p_event.m_timestamp )
|
|
{
|
|
event.m_timestamp = p_event.m_timestamp;
|
|
}
|
|
}
|
|
|
|
while ( it > m_events.begin() )
|
|
{
|
|
if ( (*( it - 1 )).m_timestamp <= p_event.m_timestamp ) break;
|
|
--it;
|
|
}
|
|
}
|
|
|
|
m_events.insert( it, p_event );
|
|
}
|
|
|
|
std::size_t midi_track::get_count() const
|
|
{
|
|
return m_events.size();
|
|
}
|
|
|
|
const midi_event & midi_track::operator [] ( std::size_t p_index ) const
|
|
{
|
|
return m_events[ p_index ];
|
|
}
|
|
|
|
midi_event & midi_track::operator [] ( std::size_t p_index )
|
|
{
|
|
return m_events[ p_index ];
|
|
}
|
|
|
|
void midi_track::remove_event( unsigned long index )
|
|
{
|
|
m_events.erase( m_events.begin() + index );
|
|
}
|
|
|
|
tempo_entry::tempo_entry(unsigned long p_timestamp, unsigned p_tempo)
|
|
{
|
|
m_timestamp = p_timestamp;
|
|
m_tempo = p_tempo;
|
|
}
|
|
|
|
void tempo_map::add_tempo( unsigned p_tempo, unsigned long p_timestamp )
|
|
{
|
|
auto it = m_entries.end();
|
|
|
|
while ( it > m_entries.begin() )
|
|
{
|
|
if ( (*( it - 1 )).m_timestamp <= p_timestamp ) break;
|
|
--it;
|
|
}
|
|
|
|
if ( it > m_entries.begin() && (*( it - 1 )).m_timestamp == p_timestamp )
|
|
{
|
|
(*( it - 1 )).m_tempo = p_tempo;
|
|
}
|
|
else
|
|
{
|
|
m_entries.insert( it, tempo_entry( p_timestamp, p_tempo ) );
|
|
}
|
|
}
|
|
|
|
unsigned long tempo_map::timestamp_to_ms( unsigned long p_timestamp, unsigned p_dtx ) const
|
|
{
|
|
unsigned long timestamp_ms = 0;
|
|
unsigned long timestamp = 0;
|
|
auto tempo_it = m_entries.begin();
|
|
unsigned current_tempo = 500000;
|
|
|
|
unsigned half_dtx = p_dtx * 500;
|
|
p_dtx = half_dtx * 2;
|
|
|
|
while ( tempo_it < m_entries.end() && timestamp + p_timestamp >= (*tempo_it).m_timestamp )
|
|
{
|
|
unsigned long delta = (*tempo_it).m_timestamp - timestamp;
|
|
timestamp_ms += ((uint64_t)current_tempo * (uint64_t)delta + half_dtx) / p_dtx;
|
|
current_tempo = (*tempo_it).m_tempo;
|
|
++tempo_it;
|
|
timestamp += delta;
|
|
p_timestamp -= delta;
|
|
}
|
|
|
|
timestamp_ms += ((uint64_t)current_tempo * (uint64_t)p_timestamp + half_dtx) / p_dtx;
|
|
|
|
return timestamp_ms;
|
|
}
|
|
|
|
std::size_t tempo_map::get_count() const
|
|
{
|
|
return m_entries.size();
|
|
}
|
|
|
|
const tempo_entry & tempo_map::operator [] ( std::size_t p_index ) const
|
|
{
|
|
return m_entries[ p_index ];
|
|
}
|
|
|
|
tempo_entry & tempo_map::operator [] ( std::size_t p_index )
|
|
{
|
|
return m_entries[ p_index ];
|
|
}
|
|
|
|
system_exclusive_entry::system_exclusive_entry(const system_exclusive_entry & p_in)
|
|
{
|
|
m_port = p_in.m_port;
|
|
m_offset = p_in.m_offset;
|
|
m_length = p_in.m_length;
|
|
}
|
|
|
|
system_exclusive_entry::system_exclusive_entry(std::size_t p_port, std::size_t p_offset, std::size_t p_length)
|
|
{
|
|
m_port = p_port;
|
|
m_offset = p_offset;
|
|
m_length = p_length;
|
|
}
|
|
|
|
unsigned system_exclusive_table::add_entry( const uint8_t * p_data, std::size_t p_size, std::size_t p_port )
|
|
{
|
|
for ( auto it = m_entries.begin(); it < m_entries.end(); ++it )
|
|
{
|
|
const system_exclusive_entry & entry = *it;
|
|
if ( p_port == entry.m_port && p_size == entry.m_length && !memcmp( p_data, &m_data[ entry.m_offset ], p_size ) )
|
|
return ((unsigned)(it - m_entries.begin()));
|
|
}
|
|
system_exclusive_entry entry( p_port, m_data.size(), p_size );
|
|
m_data.insert( m_data.end(), p_data, p_data + p_size );
|
|
m_entries.push_back( entry );
|
|
return ((unsigned)(m_entries.size() - 1));
|
|
}
|
|
|
|
void system_exclusive_table::get_entry( unsigned p_index, const uint8_t * & p_data, std::size_t & p_size, std::size_t & p_port )
|
|
{
|
|
const system_exclusive_entry & entry = m_entries[ p_index ];
|
|
p_data = &m_data[ entry.m_offset ];
|
|
p_size = entry.m_length;
|
|
p_port = entry.m_port;
|
|
}
|
|
|
|
midi_stream_event::midi_stream_event(unsigned long p_timestamp, unsigned p_event)
|
|
{
|
|
m_timestamp = p_timestamp;
|
|
m_event = p_event;
|
|
}
|
|
|
|
midi_meta_data_item::midi_meta_data_item(const midi_meta_data_item & p_in)
|
|
{
|
|
m_timestamp = p_in.m_timestamp;
|
|
m_name = p_in.m_name;
|
|
m_value = p_in.m_value;
|
|
}
|
|
|
|
midi_meta_data_item::midi_meta_data_item(unsigned long p_timestamp, const char * p_name, const char * p_value)
|
|
{
|
|
m_timestamp = p_timestamp;
|
|
m_name = p_name;
|
|
m_value = p_value;
|
|
}
|
|
|
|
void midi_meta_data::add_item( const midi_meta_data_item & p_item )
|
|
{
|
|
m_data.push_back( p_item );
|
|
}
|
|
|
|
void midi_meta_data::append( const midi_meta_data & p_data )
|
|
{
|
|
m_data.insert( m_data.end(), p_data.m_data.begin(), p_data.m_data.end() );
|
|
m_bitmap = p_data.m_bitmap;
|
|
}
|
|
|
|
bool midi_meta_data::get_item( const char * p_name, midi_meta_data_item & p_out ) const
|
|
{
|
|
for ( unsigned i = 0; i < m_data.size(); ++i )
|
|
{
|
|
const midi_meta_data_item & item = m_data[ i ];
|
|
if ( !strcasecmp( p_name, item.m_name.c_str() ) )
|
|
{
|
|
p_out = item;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool midi_meta_data::get_bitmap( std::vector<uint8_t> & p_out )
|
|
{
|
|
p_out = m_bitmap;
|
|
return p_out.size() != 0;
|
|
}
|
|
|
|
void midi_meta_data::assign_bitmap( std::vector<uint8_t>::const_iterator const& begin, std::vector<uint8_t>::const_iterator const& end )
|
|
{
|
|
m_bitmap.assign( begin, end );
|
|
}
|
|
|
|
std::size_t midi_meta_data::get_count() const
|
|
{
|
|
return m_data.size();
|
|
}
|
|
|
|
const midi_meta_data_item & midi_meta_data::operator [] ( std::size_t p_index ) const
|
|
{
|
|
return m_data[ p_index ];
|
|
}
|
|
|
|
void midi_container::encode_delta( std::vector<uint8_t> & p_out, unsigned long delta )
|
|
{
|
|
unsigned shift = 7 * 4;
|
|
while ( shift && !( delta >> shift ) )
|
|
{
|
|
shift -= 7;
|
|
}
|
|
while (shift > 0)
|
|
{
|
|
p_out.push_back( (unsigned char)( ( ( delta >> shift ) & 0x7F ) | 0x80 ) );
|
|
shift -= 7;
|
|
}
|
|
p_out.push_back( (unsigned char)( delta & 0x7F ) );
|
|
}
|
|
|
|
unsigned long midi_container::timestamp_to_ms( unsigned long p_timestamp, unsigned long p_subsong ) const
|
|
{
|
|
unsigned long timestamp_ms = 0;
|
|
unsigned long timestamp = 0;
|
|
std::size_t tempo_index = 0;
|
|
unsigned current_tempo = 500000;
|
|
|
|
unsigned half_dtx = m_dtx * 500;
|
|
unsigned p_dtx = half_dtx * 2;
|
|
|
|
unsigned long subsong_count = m_tempo_map.size();
|
|
|
|
if ( p_subsong && subsong_count )
|
|
{
|
|
for ( unsigned long i = std::min( p_subsong, subsong_count ); --i; )
|
|
{
|
|
unsigned long count = m_tempo_map[ i ].get_count();
|
|
if ( count )
|
|
{
|
|
current_tempo = m_tempo_map[ i ][ count - 1 ].m_tempo;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( p_subsong < subsong_count )
|
|
{
|
|
const tempo_map & m_entries = m_tempo_map[ p_subsong ];
|
|
|
|
std::size_t tempo_count = m_entries.get_count();
|
|
|
|
while ( tempo_index < tempo_count && timestamp + p_timestamp >= m_entries[ tempo_index ].m_timestamp )
|
|
{
|
|
unsigned long delta = m_entries[ tempo_index ].m_timestamp - timestamp;
|
|
timestamp_ms += ((uint64_t)current_tempo * (uint64_t)delta + half_dtx) / p_dtx;
|
|
current_tempo = m_entries[ tempo_index ].m_tempo;
|
|
++tempo_index;
|
|
timestamp += delta;
|
|
p_timestamp -= delta;
|
|
}
|
|
}
|
|
|
|
timestamp_ms += ((uint64_t)current_tempo * (uint64_t)p_timestamp + half_dtx) / p_dtx;
|
|
|
|
return timestamp_ms;
|
|
}
|
|
|
|
void midi_container::initialize( unsigned p_form, unsigned p_dtx )
|
|
{
|
|
m_form = p_form;
|
|
m_dtx = p_dtx;
|
|
if ( p_form != 2 )
|
|
{
|
|
m_channel_mask.resize( 1 );
|
|
m_channel_mask[ 0 ] = 0;
|
|
m_tempo_map.resize( 1 );
|
|
m_timestamp_end.resize( 1 );
|
|
m_timestamp_end[ 0 ] = 0;
|
|
m_timestamp_loop_start.resize( 1 );
|
|
m_timestamp_loop_end.resize( 1 );
|
|
}
|
|
}
|
|
|
|
void midi_container::add_track( const midi_track & p_track )
|
|
{
|
|
unsigned i;
|
|
unsigned long port_number = 0;
|
|
|
|
std::vector<uint8_t> data;
|
|
std::string device_name;
|
|
|
|
m_tracks.push_back( p_track );
|
|
|
|
for ( i = 0; i < p_track.get_count(); ++i )
|
|
{
|
|
const midi_event & event = p_track[ i ];
|
|
if ( event.m_type == midi_event::extended && event.get_data_count() >= 5 &&
|
|
event.m_data[ 0 ] == 0xFF && event.m_data[ 1 ] == 0x51 )
|
|
{
|
|
unsigned tempo = ( event.m_data[ 2 ] << 16 ) + ( event.m_data[ 3 ] << 8 ) + event.m_data[ 4 ];
|
|
if ( m_form != 2 ) m_tempo_map[ 0 ].add_tempo( tempo, event.m_timestamp );
|
|
else
|
|
{
|
|
m_tempo_map.resize( m_tracks.size() );
|
|
m_tempo_map[ m_tracks.size() - 1 ].add_tempo( tempo, event.m_timestamp );
|
|
}
|
|
}
|
|
else if ( event.m_type == midi_event::extended && event.get_data_count() >= 3 &&
|
|
event.m_data[ 0 ] == 0xFF )
|
|
{
|
|
if ( event.m_data[ 1 ] == 4 || event.m_data[1] == 9 )
|
|
{
|
|
unsigned long data_count = event.get_data_count() - 2;
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 2, data_count );
|
|
device_name.assign( data.begin(), data.begin() + data_count );
|
|
std::transform( device_name.begin(), device_name.end(), device_name.begin(), ::tolower );
|
|
}
|
|
else if ( event.m_data[ 1 ] == 0x21 )
|
|
{
|
|
port_number = event.m_data[ 2 ];
|
|
limit_port_number( port_number );
|
|
device_name.clear();
|
|
}
|
|
}
|
|
else if ( event.m_type == midi_event::note_on || event.m_type == midi_event::note_off )
|
|
{
|
|
unsigned channel = event.m_channel;
|
|
if ( device_name.length() )
|
|
{
|
|
unsigned long j, k;
|
|
for ( j = 0, k = m_device_names[ channel ].size(); j < k; ++j )
|
|
{
|
|
if ( !strcmp( m_device_names[ channel ][ j ].c_str(), device_name.c_str() ) ) break;
|
|
}
|
|
if ( j < k ) port_number = j;
|
|
else
|
|
{
|
|
m_device_names[ channel ].push_back( device_name );
|
|
port_number = k;
|
|
}
|
|
device_name.clear();
|
|
limit_port_number( port_number );
|
|
}
|
|
|
|
channel += 16 * port_number;
|
|
channel %= 48;
|
|
if ( m_form != 2 ) m_channel_mask[ 0 ] |= 1ULL << channel;
|
|
else
|
|
{
|
|
m_channel_mask.resize( m_tracks.size(), 0 );
|
|
m_channel_mask[ m_tracks.size() - 1 ] |= 1ULL << channel;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( i && m_form != 2 && p_track[ i - 1 ].m_timestamp > m_timestamp_end[ 0 ] )
|
|
m_timestamp_end[ 0 ] = p_track[ i - 1 ].m_timestamp;
|
|
else if ( m_form == 2 )
|
|
{
|
|
if ( i )
|
|
m_timestamp_end.push_back( p_track[ i - 1 ].m_timestamp );
|
|
else
|
|
m_timestamp_end.push_back( (unsigned)0 );
|
|
}
|
|
}
|
|
|
|
void midi_container::add_track_event( std::size_t p_track_index, const midi_event & p_event )
|
|
{
|
|
midi_track & track = m_tracks[ p_track_index ];
|
|
|
|
track.add_event( p_event );
|
|
|
|
if ( p_event.m_type == midi_event::extended && p_event.get_data_count() >= 5 &&
|
|
p_event.m_data[ 0 ] == 0xFF && p_event.m_data[ 1 ] == 0x51 )
|
|
{
|
|
unsigned tempo = ( p_event.m_data[ 2 ] << 16 ) + ( p_event.m_data[ 3 ] << 8 ) + p_event.m_data[ 4 ];
|
|
if ( m_form != 2 ) m_tempo_map[ 0 ].add_tempo( tempo, p_event.m_timestamp );
|
|
else
|
|
{
|
|
m_tempo_map.resize( m_tracks.size() );
|
|
m_tempo_map[ p_track_index ].add_tempo( tempo, p_event.m_timestamp );
|
|
}
|
|
}
|
|
else if ( p_event.m_type == midi_event::note_on || p_event.m_type == midi_event::note_off )
|
|
{
|
|
if ( m_form != 2 ) m_channel_mask[ 0 ] |= 1ULL << p_event.m_channel;
|
|
else
|
|
{
|
|
m_channel_mask.resize( m_tracks.size(), 0 );
|
|
m_channel_mask[ p_track_index ] |= 1ULL << p_event.m_channel;
|
|
}
|
|
}
|
|
|
|
if ( m_form != 2 && p_event.m_timestamp > m_timestamp_end[ 0 ] )
|
|
{
|
|
m_timestamp_end[ 0 ] = p_event.m_timestamp;
|
|
}
|
|
else if ( m_form == 2 && p_event.m_timestamp > m_timestamp_end[ p_track_index ] )
|
|
{
|
|
m_timestamp_end[ p_track_index ] = p_event.m_timestamp;
|
|
}
|
|
}
|
|
|
|
void midi_container::merge_tracks( const midi_container & p_source )
|
|
{
|
|
for ( unsigned i = 0; i < p_source.m_tracks.size(); i++ )
|
|
{
|
|
add_track( p_source.m_tracks[ i ] );
|
|
}
|
|
}
|
|
|
|
void midi_container::set_track_count( unsigned count )
|
|
{
|
|
m_tracks.resize( count );
|
|
}
|
|
|
|
void midi_container::set_extra_meta_data( const midi_meta_data & p_data )
|
|
{
|
|
m_extra_meta_data = p_data;
|
|
}
|
|
|
|
void midi_container::apply_hackfix( unsigned hack )
|
|
{
|
|
switch (hack)
|
|
{
|
|
case 0:
|
|
for (unsigned i = 0; i < m_tracks.size(); ++i)
|
|
{
|
|
midi_track & t = m_tracks[ i ];
|
|
for ( unsigned j = 0; j < t.get_count(); )
|
|
{
|
|
if ( t[ j ].m_type != midi_event::extended &&
|
|
t[ j ].m_channel == 16 )
|
|
{
|
|
t.remove_event( j );
|
|
}
|
|
else
|
|
{
|
|
++j;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
for (unsigned i = 0; i < m_tracks.size(); ++i)
|
|
{
|
|
midi_track & t = m_tracks[ i ];
|
|
for ( unsigned j = 0; j < t.get_count(); )
|
|
{
|
|
if ( t[ j ].m_type != midi_event::extended &&
|
|
( t[ j ].m_channel - 10 < 6 ) )
|
|
{
|
|
t.remove_event( j );
|
|
}
|
|
else
|
|
{
|
|
++j;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void midi_container::serialize_as_stream( unsigned long subsong,
|
|
std::vector<midi_stream_event> & p_stream,
|
|
system_exclusive_table & p_system_exclusive,
|
|
unsigned long & loop_start,
|
|
unsigned long & loop_end,
|
|
unsigned clean_flags ) const
|
|
{
|
|
std::vector<uint8_t> data;
|
|
std::vector<std::size_t> track_positions;
|
|
std::vector<uint8_t> port_numbers;
|
|
std::vector<std::string> device_names;
|
|
std::size_t track_count = m_tracks.size();
|
|
|
|
unsigned long tick_loop_start = get_timestamp_loop_start(subsong);
|
|
unsigned long tick_loop_end = get_timestamp_loop_end(subsong);
|
|
unsigned long local_loop_start = ~0UL;
|
|
unsigned long local_loop_end = ~0UL;
|
|
|
|
track_positions.resize( track_count, 0 );
|
|
port_numbers.resize( track_count, 0 );
|
|
device_names.resize( track_count );
|
|
|
|
bool clean_emidi = !!( clean_flags & clean_flag_emidi );
|
|
bool clean_instruments = !!( clean_flags & clean_flag_instruments );
|
|
bool clean_banks = !!( clean_flags & clean_flag_banks );
|
|
|
|
if ( clean_emidi )
|
|
{
|
|
for ( unsigned i = 0; i < track_count; ++i )
|
|
{
|
|
bool skip_track = false;
|
|
const midi_track & track = m_tracks[ i ];
|
|
for ( unsigned j = 0; j < track.get_count(); ++j )
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
if ( event.m_type == midi_event::control_change &&
|
|
event.m_data[ 0 ] == 110 )
|
|
{
|
|
if ( event.m_data[ 1 ] != 0 && event.m_data[ 1 ] != 1 && event.m_data[ 1 ] != 127 )
|
|
{
|
|
skip_track = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ( skip_track )
|
|
{
|
|
track_positions[ i ] = track.get_count();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( m_form == 2 )
|
|
{
|
|
for ( unsigned long i = 0; i < track_count; ++i )
|
|
{
|
|
if ( i != subsong ) track_positions[ i ] = m_tracks[ i ].get_count();
|
|
}
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
unsigned long next_timestamp = ~0UL;
|
|
std::size_t next_track = 0;
|
|
for ( unsigned i = 0; i < track_count; ++i )
|
|
{
|
|
if ( track_positions[ i ] >= m_tracks[ i ].get_count() ) continue;
|
|
if ( m_tracks[ i ][ track_positions[ i ] ].m_timestamp < next_timestamp )
|
|
{
|
|
next_timestamp = m_tracks[ i ][ track_positions[ i ] ].m_timestamp;
|
|
next_track = i;
|
|
}
|
|
}
|
|
if ( next_timestamp == ~0UL ) break;
|
|
|
|
bool filtered = false;
|
|
|
|
if ( clean_instruments || clean_banks )
|
|
{
|
|
const midi_event & event = m_tracks[ next_track ][ track_positions[ next_track ] ];
|
|
if ( clean_instruments && event.m_type == midi_event::program_change ) filtered = true;
|
|
else if ( clean_banks && event.m_type == midi_event::control_change &&
|
|
( event.m_data[ 0 ] == 0x00 || event.m_data[ 0 ] == 0x20 ) ) filtered = true;
|
|
}
|
|
|
|
if ( !filtered )
|
|
{
|
|
unsigned long tempo_track = 0;
|
|
if ( m_form == 2 && subsong ) tempo_track = subsong;
|
|
|
|
const midi_event & event = m_tracks[ next_track ][ track_positions[ next_track ] ];
|
|
|
|
if ( local_loop_start == ~0UL && event.m_timestamp >= tick_loop_start )
|
|
local_loop_start = p_stream.size();
|
|
if ( local_loop_end == ~0UL && event.m_timestamp > tick_loop_end )
|
|
local_loop_end = p_stream.size();
|
|
|
|
unsigned long timestamp_ms = timestamp_to_ms( event.m_timestamp, tempo_track );
|
|
if ( event.m_type != midi_event::extended )
|
|
{
|
|
if ( device_names[ next_track ].length() )
|
|
{
|
|
unsigned long i, j;
|
|
for ( i = 0, j = m_device_names[ event.m_channel ].size(); i < j; ++i )
|
|
{
|
|
if ( !strcmp( m_device_names[ event.m_channel ][ i ].c_str(), device_names[ next_track ].c_str() ) ) break;
|
|
}
|
|
port_numbers[ next_track ] = (uint8_t) i;
|
|
device_names[ next_track ].clear();
|
|
limit_port_number( port_numbers[ next_track ] );
|
|
}
|
|
|
|
uint32_t event_code = ( ( event.m_type + 8 ) << 4 ) + event.m_channel;
|
|
if ( event.m_data_count >= 1 ) event_code += event.m_data[ 0 ] << 8;
|
|
if ( event.m_data_count >= 2 ) event_code += event.m_data[ 1 ] << 16;
|
|
event_code += port_numbers[ next_track ] << 24;
|
|
p_stream.push_back( midi_stream_event( timestamp_ms, event_code ) );
|
|
}
|
|
else
|
|
{
|
|
std::size_t data_count = event.get_data_count();
|
|
if ( data_count >= 3 && event.m_data[ 0 ] == 0xF0 )
|
|
{
|
|
if ( device_names[ next_track ].length() )
|
|
{
|
|
unsigned long i, j;
|
|
for ( i = 0, j = m_device_names[ event.m_channel ].size(); i < j; ++i )
|
|
{
|
|
if ( !strcmp( m_device_names[ event.m_channel ][ i ].c_str(), device_names[ next_track ].c_str() ) ) break;
|
|
}
|
|
port_numbers[ next_track ] = (uint8_t) i;
|
|
device_names[ next_track ].clear();
|
|
limit_port_number( port_numbers[ next_track ] );
|
|
}
|
|
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 0, data_count );
|
|
if ( data[ data_count - 1 ] == 0xF7 )
|
|
{
|
|
uint32_t system_exclusive_index = p_system_exclusive.add_entry( &data[0], data_count, port_numbers[ next_track ] );
|
|
p_stream.push_back( midi_stream_event( timestamp_ms, system_exclusive_index | 0x80000000 ) );
|
|
}
|
|
}
|
|
else if ( data_count >= 3 && event.m_data[ 0 ] == 0xFF )
|
|
{
|
|
if ( event.m_data[ 1 ] == 4 || event.m_data[ 1 ] == 9 )
|
|
{
|
|
unsigned long _data_count = event.get_data_count() - 2;
|
|
data.resize( _data_count );
|
|
event.copy_data( &data[0], 2, _data_count );
|
|
device_names[ next_track ].clear();
|
|
device_names[ next_track ].assign( data.begin(), data.begin() + _data_count );
|
|
std::transform( device_names[ next_track ].begin(), device_names[ next_track ].end(), device_names[ next_track ].begin(), ::tolower );
|
|
}
|
|
else if ( event.m_data[ 1 ] == 0x21 )
|
|
{
|
|
port_numbers[ next_track ] = event.m_data[ 2 ];
|
|
device_names[ next_track ].clear();
|
|
limit_port_number( port_numbers[ next_track ] );
|
|
}
|
|
}
|
|
else if ( data_count == 1 && event.m_data[ 0 ] >= 0xF8 )
|
|
{
|
|
if ( device_names[ next_track ].length() )
|
|
{
|
|
unsigned long i, j;
|
|
for ( i = 0, j = m_device_names[ event.m_channel ].size(); i < j; ++i )
|
|
{
|
|
if ( !strcmp( m_device_names[ event.m_channel ][ i ].c_str(), device_names[ next_track ].c_str() ) ) break;
|
|
}
|
|
port_numbers[ next_track ] = (uint8_t) i;
|
|
device_names[ next_track ].clear();
|
|
limit_port_number( port_numbers[ next_track ] );
|
|
}
|
|
|
|
uint32_t event_code = port_numbers[ next_track ] << 24;
|
|
event_code += event.m_data[ 0 ];
|
|
p_stream.push_back( midi_stream_event( timestamp_ms, event_code ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
track_positions[ next_track ]++;
|
|
}
|
|
|
|
loop_start = local_loop_start;
|
|
loop_end = local_loop_end;
|
|
}
|
|
|
|
void midi_container::serialize_as_standard_midi_file( std::vector<uint8_t> & p_midi_file ) const
|
|
{
|
|
if ( !m_tracks.size() ) return;
|
|
|
|
std::vector<uint8_t> data;
|
|
|
|
const char signature[] = "MThd";
|
|
p_midi_file.insert( p_midi_file.end(), signature, signature + 4 );
|
|
p_midi_file.push_back( 0 );
|
|
p_midi_file.push_back( 0 );
|
|
p_midi_file.push_back( 0 );
|
|
p_midi_file.push_back( 6 );
|
|
p_midi_file.push_back( 0 );
|
|
p_midi_file.push_back( m_form );
|
|
p_midi_file.push_back( (uint8_t) (m_tracks.size() >> 8) );
|
|
p_midi_file.push_back( (uint8_t) m_tracks.size() );
|
|
p_midi_file.push_back( (m_dtx >> 8) );
|
|
p_midi_file.push_back( m_dtx );
|
|
|
|
for ( unsigned i = 0; i < m_tracks.size(); ++i )
|
|
{
|
|
const midi_track & track = m_tracks[ i ];
|
|
unsigned long last_timestamp = 0;
|
|
unsigned char last_event_code = 0xFF;
|
|
std::size_t length_offset;
|
|
|
|
const char _signature[] = "MTrk";
|
|
p_midi_file.insert( p_midi_file.end(), _signature, _signature + 4 );
|
|
|
|
length_offset = p_midi_file.size();
|
|
p_midi_file.push_back( 0 );
|
|
p_midi_file.push_back( 0 );
|
|
p_midi_file.push_back( 0 );
|
|
p_midi_file.push_back( 0 );
|
|
|
|
for ( unsigned j = 0; j < track.get_count(); ++j )
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
encode_delta( p_midi_file, event.m_timestamp - last_timestamp );
|
|
last_timestamp = event.m_timestamp;
|
|
if ( event.m_type != midi_event::extended )
|
|
{
|
|
const unsigned char event_code = ( ( event.m_type + 8 ) << 4 ) + event.m_channel;
|
|
if ( event_code != last_event_code )
|
|
{
|
|
p_midi_file.push_back( event_code );
|
|
last_event_code = event_code;
|
|
}
|
|
p_midi_file.insert( p_midi_file.end(), event.m_data, event.m_data + event.m_data_count );
|
|
}
|
|
else
|
|
{
|
|
std::size_t data_count = event.get_data_count();
|
|
if ( data_count >= 1 )
|
|
{
|
|
if ( event.m_data[ 0 ] == 0xF0 )
|
|
{
|
|
--data_count;
|
|
p_midi_file.push_back( 0xF0 );
|
|
encode_delta( p_midi_file, data_count );
|
|
if ( data_count )
|
|
{
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 1, data_count );
|
|
p_midi_file.insert( p_midi_file.end(), data.begin(), data.begin() + data_count );
|
|
}
|
|
}
|
|
else if ( event.m_data[ 0 ] == 0xFF && data_count >= 2 )
|
|
{
|
|
data_count -= 2;
|
|
p_midi_file.push_back( 0xFF );
|
|
p_midi_file.push_back( event.m_data[ 1 ] );
|
|
encode_delta( p_midi_file, data_count );
|
|
if ( data_count )
|
|
{
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 2, data_count );
|
|
p_midi_file.insert( p_midi_file.end(), data.begin(), data.begin() + data_count );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 1, data_count );
|
|
p_midi_file.insert( p_midi_file.end(), data.begin(), data.begin() + data_count );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::size_t track_length = p_midi_file.size() - length_offset - 4;
|
|
p_midi_file[ length_offset + 0 ] = (unsigned char)( track_length >> 24 );
|
|
p_midi_file[ length_offset + 1 ] = (unsigned char)( track_length >> 16 );
|
|
p_midi_file[ length_offset + 2 ] = (unsigned char)( track_length >> 8 );
|
|
p_midi_file[ length_offset + 3 ] = (unsigned char)track_length;
|
|
}
|
|
}
|
|
|
|
void midi_container::promote_to_type1()
|
|
{
|
|
if ( m_form == 0 && m_tracks.size() <= 2 )
|
|
{
|
|
bool meter_track_present = false;
|
|
midi_track new_tracks[17];
|
|
midi_track original_data_track = m_tracks[ m_tracks.size() - 1 ];
|
|
if ( m_tracks.size() > 1 )
|
|
{
|
|
new_tracks[0] = m_tracks[0];
|
|
meter_track_present = true;
|
|
}
|
|
|
|
m_tracks.resize( 0 );
|
|
|
|
for ( std::size_t i = 0; i < original_data_track.get_count(); ++i )
|
|
{
|
|
const midi_event & event = original_data_track[ i ];
|
|
|
|
if ( event.m_type != midi_event::extended )
|
|
{
|
|
new_tracks[ 1 + event.m_channel ].add_event( event );
|
|
}
|
|
else
|
|
{
|
|
if ( event.m_data[0] != 0xFF || event.get_data_count() < 2 || event.m_data[1] != 0x2F )
|
|
{
|
|
new_tracks[ 0 ].add_event( event );
|
|
}
|
|
else
|
|
{
|
|
if ( !meter_track_present )
|
|
new_tracks[ 0 ].add_event( event );
|
|
for ( std::size_t j = 1; j < 17; ++j )
|
|
{
|
|
new_tracks[ j ].add_event( event );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( std::size_t i = 0; i < 17; ++i )
|
|
{
|
|
if ( new_tracks[ i ].get_count() > 1 )
|
|
add_track( new_tracks[ i ] );
|
|
}
|
|
|
|
m_form = 1;
|
|
}
|
|
}
|
|
|
|
unsigned long midi_container::get_subsong_count() const
|
|
{
|
|
unsigned long subsong_count = 0;
|
|
for ( unsigned i = 0; i < m_channel_mask.size(); ++i )
|
|
{
|
|
if ( m_channel_mask[ i ] ) ++subsong_count;
|
|
}
|
|
return subsong_count;
|
|
}
|
|
|
|
unsigned long midi_container::get_subsong( unsigned long p_index ) const
|
|
{
|
|
for ( unsigned i = 0; i < m_channel_mask.size(); ++i )
|
|
{
|
|
if ( m_channel_mask[ i ] )
|
|
{
|
|
if ( p_index ) --p_index;
|
|
else return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
unsigned long midi_container::get_timestamp_end(unsigned long subsong, bool ms /* = false */) const
|
|
{
|
|
unsigned long tempo_track = 0;
|
|
unsigned long timestamp = m_timestamp_end[ 0 ];
|
|
if ( m_form == 2 && subsong )
|
|
{
|
|
tempo_track = subsong;
|
|
timestamp = m_timestamp_end[ subsong ];
|
|
}
|
|
if ( !ms ) return timestamp;
|
|
else return timestamp_to_ms( timestamp, tempo_track );
|
|
}
|
|
|
|
unsigned midi_container::get_format() const
|
|
{
|
|
return m_form;
|
|
}
|
|
|
|
unsigned midi_container::get_track_count() const
|
|
{
|
|
return (unsigned) m_tracks.size();
|
|
}
|
|
|
|
unsigned midi_container::get_channel_count( unsigned long subsong ) const
|
|
{
|
|
unsigned count = 0;
|
|
uint64_t j = 1;
|
|
for (unsigned i = 0; i < 48; ++i, j <<= 1)
|
|
{
|
|
if ( m_channel_mask[ subsong ] & j ) ++count;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
unsigned long midi_container::get_timestamp_loop_start( unsigned long subsong, bool ms /* = false */ ) const
|
|
{
|
|
unsigned long tempo_track = 0;
|
|
unsigned long timestamp = m_timestamp_loop_start[ 0 ];
|
|
if ( m_form == 2 && subsong )
|
|
{
|
|
tempo_track = subsong;
|
|
timestamp = m_timestamp_loop_start[ subsong ];
|
|
}
|
|
if ( !ms ) return timestamp;
|
|
else if ( timestamp != ~0UL ) return timestamp_to_ms( timestamp, tempo_track );
|
|
else return ~0UL;
|
|
}
|
|
|
|
unsigned long midi_container::get_timestamp_loop_end( unsigned long subsong, bool ms /* = false */ ) const
|
|
{
|
|
unsigned long tempo_track = 0;
|
|
unsigned long timestamp = m_timestamp_loop_end[ 0 ];
|
|
if ( m_form == 2 && subsong )
|
|
{
|
|
tempo_track = subsong;
|
|
timestamp = m_timestamp_loop_end[ subsong ];
|
|
}
|
|
if ( !ms ) return timestamp;
|
|
else if ( timestamp != ~0UL ) return timestamp_to_ms( timestamp, tempo_track );
|
|
else return ~0UL;
|
|
}
|
|
|
|
/* TODO: Use iconv or libintl or something to probe for code pages and convert some mess to UTF-8 */
|
|
static void convert_mess_to_utf8( const char * p_src, std::size_t p_src_len, std::string & p_dst )
|
|
{
|
|
p_dst.assign( p_src, p_src + p_src_len );
|
|
}
|
|
|
|
void midi_container::get_meta_data( unsigned long subsong, midi_meta_data & p_out )
|
|
{
|
|
char temp[32];
|
|
std::string convert;
|
|
|
|
std::vector<uint8_t> data;
|
|
|
|
bool type_found = false;
|
|
bool type_non_gm_found = false;
|
|
|
|
for ( unsigned long i = 0; i < m_tracks.size(); ++i )
|
|
{
|
|
if ( m_form == 2 && i != subsong ) continue;
|
|
|
|
unsigned long tempo_track = 0;
|
|
if ( m_form == 2 ) tempo_track = i;
|
|
|
|
const midi_track & track = m_tracks[ i ];
|
|
for ( unsigned j = 0; j < track.get_count(); ++j )
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
if ( event.m_type == midi_event::extended )
|
|
{
|
|
std::size_t data_count = event.get_data_count();
|
|
if ( !type_non_gm_found && data_count >= 1 && event.m_data[ 0 ] == 0xF0 )
|
|
{
|
|
unsigned char test = 0;
|
|
unsigned char test2 = 0;
|
|
if ( data_count > 1 ) test = event.m_data[ 1 ];
|
|
if ( data_count > 3 ) test2 = event.m_data[ 3 ];
|
|
|
|
const char * type = NULL;
|
|
|
|
switch( test )
|
|
{
|
|
case 0x7E:
|
|
type_found = true;
|
|
break;
|
|
case 0x43:
|
|
type = "XG";
|
|
break;
|
|
case 0x42:
|
|
type = "X5";
|
|
break;
|
|
case 0x41:
|
|
if ( test2 == 0x42 ) type = "GS";
|
|
else if ( test2 == 0x16 ) type = "MT-32";
|
|
else if ( test2 == 0x14 ) type = "D-50";
|
|
}
|
|
|
|
if ( type )
|
|
{
|
|
type_found = true;
|
|
type_non_gm_found = true;
|
|
p_out.add_item( midi_meta_data_item( timestamp_to_ms( event.m_timestamp, tempo_track ), "type", type ) );
|
|
}
|
|
}
|
|
else if ( data_count >= 2 && event.m_data[ 0 ] == 0xFF )
|
|
{
|
|
data_count -= 2;
|
|
switch ( event.m_data[ 1 ] )
|
|
{
|
|
case 6:
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 2, data_count );
|
|
convert_mess_to_utf8( ( const char * ) &data[0], data_count, convert );
|
|
p_out.add_item( midi_meta_data_item( timestamp_to_ms( event.m_timestamp, tempo_track ), "track_marker", convert.c_str() ) );
|
|
break;
|
|
|
|
case 2:
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 2, data_count );
|
|
convert_mess_to_utf8( ( const char * ) &data[0], data_count, convert );
|
|
p_out.add_item( midi_meta_data_item( timestamp_to_ms( event.m_timestamp, tempo_track ), "copyright", convert.c_str() ) );
|
|
break;
|
|
|
|
case 1:
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 2, data_count );
|
|
convert_mess_to_utf8( ( const char * ) &data[0], data_count, convert );
|
|
snprintf(temp, 31, "track_text_%02lu", i);
|
|
p_out.add_item( midi_meta_data_item( timestamp_to_ms( event.m_timestamp, tempo_track ), temp, convert.c_str() ) );
|
|
break;
|
|
|
|
case 3:
|
|
case 4:
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 2, data_count );
|
|
convert_mess_to_utf8( ( const char * ) &data[0], data_count, convert );
|
|
snprintf(temp, 31, "track_name_%02lu", i);
|
|
p_out.add_item( midi_meta_data_item( timestamp_to_ms( event.m_timestamp, tempo_track ), temp, convert.c_str() ) );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( type_found && !type_non_gm_found )
|
|
{
|
|
p_out.add_item( midi_meta_data_item( 0, "type", "GM" ) );
|
|
}
|
|
|
|
p_out.append( m_extra_meta_data );
|
|
}
|
|
|
|
void midi_container::trim_tempo_map( unsigned long p_index, unsigned long base_timestamp )
|
|
{
|
|
if ( p_index < m_tempo_map.size() )
|
|
{
|
|
tempo_map & map = m_tempo_map[ p_index ];
|
|
|
|
for ( unsigned long i = 0, j = map.get_count(); i < j; ++i )
|
|
{
|
|
tempo_entry & entry = map[ i ];
|
|
if ( entry.m_timestamp >= base_timestamp )
|
|
entry.m_timestamp -= base_timestamp;
|
|
else
|
|
entry.m_timestamp = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void midi_container::trim_range_of_tracks(unsigned long start, unsigned long end)
|
|
{
|
|
unsigned long timestamp_first_note = ~0UL;
|
|
|
|
for (unsigned long i = start; i <= end; ++i)
|
|
{
|
|
unsigned long j, k;
|
|
|
|
const midi_track & track = m_tracks[ i ];
|
|
|
|
for (j = 0, k = track.get_count(); j < k; ++j)
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
|
|
if ( event.m_type == midi_event::note_on && event.m_data[ 0 ] )
|
|
break;
|
|
}
|
|
|
|
if ( j < k )
|
|
{
|
|
if ( track[ j ].m_timestamp < timestamp_first_note )
|
|
timestamp_first_note = track[ j ].m_timestamp;
|
|
}
|
|
}
|
|
|
|
if ( timestamp_first_note < ~0UL && timestamp_first_note > 0 )
|
|
{
|
|
for (unsigned long i = start; i <= end; ++i)
|
|
{
|
|
midi_track & track = m_tracks[ i ];
|
|
|
|
for (unsigned long j = 0, k = track.get_count(); j < k; ++j)
|
|
{
|
|
midi_event & event = track[ j ];
|
|
if ( event.m_timestamp >= timestamp_first_note )
|
|
event.m_timestamp -= timestamp_first_note;
|
|
else
|
|
event.m_timestamp = 0;
|
|
}
|
|
}
|
|
|
|
if ( start == end )
|
|
{
|
|
trim_tempo_map( start, timestamp_first_note );
|
|
|
|
m_timestamp_end[ start ] -= timestamp_first_note;
|
|
|
|
if ( m_timestamp_loop_end[ start ] != ~0UL )
|
|
m_timestamp_loop_end[ start ] -= timestamp_first_note;
|
|
if ( m_timestamp_loop_start[ start ] != ~0UL )
|
|
{
|
|
if ( m_timestamp_loop_start[ start ] > timestamp_first_note )
|
|
m_timestamp_loop_start[ start ] -= timestamp_first_note;
|
|
else
|
|
m_timestamp_loop_start[ start ] = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trim_tempo_map( 0, timestamp_first_note );
|
|
|
|
m_timestamp_end[ 0 ] -= timestamp_first_note;
|
|
|
|
if ( m_timestamp_loop_end[ 0 ] != ~0UL )
|
|
m_timestamp_loop_end[ 0 ] -= timestamp_first_note;
|
|
if ( m_timestamp_loop_start[ 0 ] != ~0UL )
|
|
{
|
|
if ( m_timestamp_loop_start[ 0 ] > timestamp_first_note )
|
|
m_timestamp_loop_start[ 0 ] -= timestamp_first_note;
|
|
else
|
|
m_timestamp_loop_start[ 0 ] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void midi_container::trim_start()
|
|
{
|
|
if (m_form == 2)
|
|
{
|
|
for (unsigned long i = 0, j = m_tracks.size(); i < j; ++i)
|
|
{
|
|
trim_range_of_tracks(i, i);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trim_range_of_tracks(0, m_tracks.size() - 1);
|
|
}
|
|
}
|
|
|
|
void midi_container::split_by_instrument_changes(split_callback cb)
|
|
{
|
|
if (m_form != 1) /* This would literally die on anything else */
|
|
return;
|
|
|
|
for (unsigned long i = 0, j = m_tracks.size(); i < j; ++i)
|
|
{
|
|
midi_track source_track = m_tracks[0];
|
|
|
|
m_tracks.erase(m_tracks.begin());
|
|
|
|
midi_track output_track;
|
|
midi_track program_change;
|
|
|
|
for (unsigned long k = 0, l = source_track.get_count(); k < l; ++k)
|
|
{
|
|
const midi_event & event = source_track[ k ];
|
|
if ( event.m_type == midi_event::program_change ||
|
|
( event.m_type == midi_event::control_change &&
|
|
(event.m_data[0] == 0 || event.m_data[0] == 0x20)))
|
|
{
|
|
program_change.add_event( event );
|
|
}
|
|
else
|
|
{
|
|
if (program_change.get_count())
|
|
{
|
|
if (output_track.get_count())
|
|
m_tracks.push_back( output_track );
|
|
output_track = program_change;
|
|
if (cb)
|
|
{
|
|
unsigned long timestamp = 0;
|
|
uint8_t bank_msb = 0, bank_lsb = 0, instrument = 0;
|
|
for (int i = 0, j = program_change.get_count(); i < j; ++i)
|
|
{
|
|
const midi_event & ev = program_change[i];
|
|
if (ev.m_type == midi_event::program_change)
|
|
instrument = ev.m_data[0];
|
|
else if (ev.m_data[0] == 0)
|
|
bank_msb = ev.m_data[1];
|
|
else
|
|
bank_lsb = ev.m_data[1];
|
|
if (ev.m_timestamp > timestamp)
|
|
timestamp = ev.m_timestamp;
|
|
}
|
|
|
|
std::string name = cb(bank_msb, bank_lsb, instrument);
|
|
|
|
std::vector<uint8_t> data;
|
|
|
|
data.resize(name.length() + 2);
|
|
|
|
data[0] = 0xFF;
|
|
data[1] = 0x03;
|
|
|
|
std::copy(name.begin(), name.end(), data.begin() + 2);
|
|
|
|
output_track.add_event(midi_event(timestamp, midi_event::extended, 0, &data[0], data.size()));
|
|
}
|
|
program_change = midi_track();
|
|
}
|
|
output_track.add_event( event );
|
|
}
|
|
}
|
|
|
|
if (output_track.get_count())
|
|
m_tracks.push_back(output_track);
|
|
}
|
|
}
|
|
|
|
void midi_container::scan_for_loops( bool p_xmi_loops, bool p_marker_loops, bool p_rpgmaker_loops, bool p_touhou_loops )
|
|
{
|
|
std::vector<uint8_t> data;
|
|
|
|
unsigned long subsong_count = m_form == 2 ? m_tracks.size() : 1;
|
|
|
|
m_timestamp_loop_start.resize( subsong_count );
|
|
m_timestamp_loop_end.resize( subsong_count );
|
|
|
|
for ( unsigned long i = 0; i < subsong_count; ++i )
|
|
{
|
|
m_timestamp_loop_start[ i ] = ~0UL;
|
|
m_timestamp_loop_end[ i ] = ~0UL;
|
|
}
|
|
|
|
if ( p_touhou_loops && m_form == 0 )
|
|
{
|
|
bool loop_start_found = false;
|
|
bool loop_end_found = false;
|
|
bool errored = false;
|
|
|
|
for ( unsigned long i = 0; !errored && i < m_tracks.size(); ++i )
|
|
{
|
|
const midi_track & track = m_tracks[ i ];
|
|
for ( unsigned long j = 0; !errored && j < track.get_count(); ++j )
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
if ( event.m_type == midi_event::control_change )
|
|
{
|
|
if ( event.m_data[ 0 ] == 2 )
|
|
{
|
|
if ( event.m_data[ 1 ] != 0 )
|
|
{
|
|
errored = true;
|
|
break;
|
|
}
|
|
m_timestamp_loop_start[ 0 ] = event.m_timestamp;
|
|
loop_start_found = true;
|
|
}
|
|
if ( event.m_data[ 0 ] == 4 )
|
|
{
|
|
if ( event.m_data[ 1 ] != 0 )
|
|
{
|
|
errored = true;
|
|
break;
|
|
}
|
|
m_timestamp_loop_end[ 0 ] = event.m_timestamp;
|
|
loop_end_found = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( errored )
|
|
{
|
|
m_timestamp_loop_start[ 0 ] = ~0UL;
|
|
m_timestamp_loop_end[ 0 ] = ~0UL;
|
|
}
|
|
}
|
|
|
|
if ( p_rpgmaker_loops )
|
|
{
|
|
bool emidi_commands_found = false;
|
|
|
|
for ( unsigned long i = 0; i < m_tracks.size(); ++i )
|
|
{
|
|
unsigned long subsong = 0;
|
|
if ( m_form == 2 ) subsong = i;
|
|
|
|
const midi_track & track = m_tracks[ i ];
|
|
for ( unsigned long j = 0; j < track.get_count(); ++j )
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
if ( event.m_type == midi_event::control_change &&
|
|
( event.m_data[ 0 ] == 110 || event.m_data[ 0 ] == 111 ) )
|
|
{
|
|
if ( event.m_data[ 0 ] == 110 )
|
|
{
|
|
emidi_commands_found = true;
|
|
break;
|
|
}
|
|
{
|
|
if ( m_timestamp_loop_start[ subsong ] == ~0UL || m_timestamp_loop_start[ subsong ] > event.m_timestamp )
|
|
{
|
|
m_timestamp_loop_start[ subsong ] = event.m_timestamp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( emidi_commands_found )
|
|
{
|
|
m_timestamp_loop_start[ subsong ] = ~0UL;
|
|
m_timestamp_loop_end[ subsong ] = ~0UL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( p_xmi_loops )
|
|
{
|
|
for ( unsigned long i = 0; i < m_tracks.size(); ++i )
|
|
{
|
|
unsigned long subsong = 0;
|
|
if ( m_form == 2 ) subsong = i;
|
|
|
|
const midi_track & track = m_tracks[ i ];
|
|
for ( unsigned long j = 0; j < track.get_count(); ++j )
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
if ( event.m_type == midi_event::control_change &&
|
|
( event.m_data[ 0 ] >= 0x74 && event.m_data[ 0 ] <= 0x77 ) )
|
|
{
|
|
if ( event.m_data[ 0 ] == 0x74 || event.m_data[ 0 ] == 0x76 )
|
|
{
|
|
if ( m_timestamp_loop_start[ subsong ] == ~0UL || m_timestamp_loop_start[ subsong ] > event.m_timestamp )
|
|
{
|
|
m_timestamp_loop_start[ subsong ] = event.m_timestamp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_timestamp_loop_end[ subsong ] == ~0UL || m_timestamp_loop_end[ subsong ] < event.m_timestamp )
|
|
{
|
|
m_timestamp_loop_end[ subsong ] = event.m_timestamp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( p_marker_loops )
|
|
{
|
|
for ( unsigned long i = 0; i < m_tracks.size(); ++i )
|
|
{
|
|
unsigned long subsong = 0;
|
|
if ( m_form == 2 ) subsong = i;
|
|
|
|
const midi_track & track = m_tracks[ i ];
|
|
for ( unsigned long j = 0; j < track.get_count(); ++j )
|
|
{
|
|
const midi_event & event = track[ j ];
|
|
if ( event.m_type == midi_event::extended &&
|
|
event.get_data_count() >= 9 &&
|
|
event.m_data[ 0 ] == 0xFF && event.m_data[ 1 ] == 0x06 )
|
|
{
|
|
unsigned long data_count = event.get_data_count() - 2;
|
|
data.resize( data_count );
|
|
event.copy_data( &data[0], 2, data_count );
|
|
|
|
if ( data_count == 9 && !strncasecmp( (const char *) &data[0], "loopStart", 9 ) )
|
|
{
|
|
if ( m_timestamp_loop_start[ subsong ] == ~0UL || m_timestamp_loop_start[ subsong ] > event.m_timestamp )
|
|
{
|
|
m_timestamp_loop_start[ subsong ] = event.m_timestamp;
|
|
}
|
|
}
|
|
else if ( data_count == 7 && !strncasecmp( (const char *) &data[0], "loopEnd", 7 ) )
|
|
{
|
|
if ( m_timestamp_loop_end[ subsong ] == ~0UL || m_timestamp_loop_end[ subsong ] < event.m_timestamp )
|
|
{
|
|
m_timestamp_loop_end[ subsong ] = event.m_timestamp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sanity
|
|
|
|
for ( unsigned long i = 0; i < subsong_count; ++i )
|
|
{
|
|
unsigned long timestamp_song_end;
|
|
if ( m_form == 2 )
|
|
timestamp_song_end = m_tracks[i][m_tracks[i].get_count()-1].m_timestamp;
|
|
else
|
|
{
|
|
timestamp_song_end = 0;
|
|
for (unsigned long j = 0; j < m_tracks.size(); ++j)
|
|
{
|
|
const midi_track & track = m_tracks[j];
|
|
unsigned long timestamp = track[track.get_count()-1].m_timestamp;
|
|
if (timestamp > timestamp_song_end)
|
|
timestamp_song_end = timestamp;
|
|
}
|
|
}
|
|
if ( m_timestamp_loop_start[ i ] != ~0UL && ( ( m_timestamp_loop_start[ i ] == m_timestamp_loop_end[ i ] ) || ( m_timestamp_loop_start[ i ] == timestamp_song_end ) ) )
|
|
{
|
|
m_timestamp_loop_start[ i ] = ~0UL;
|
|
m_timestamp_loop_end[ i ] = ~0UL;
|
|
}
|
|
}
|
|
}
|