#include <sequencer.h>
|
||||||||||||
|
Definition at line 586 of file jdkmidi_sequencer.cpp. References num_tracks, and track_processors.
00590 : 00591 solo_mode(false), 00592 tempo_scale(100), 00593 num_tracks( m->GetNumTracks() ), 00594 state( this, m,n ) // TODO: fix this hack 00595 { 00596 00597 for( int i=0; i<num_tracks; ++i ) 00598 { 00599 track_processors[i] = new MIDISequencerTrackProcessor; 00600 } 00601 } |
|
|
Definition at line 604 of file jdkmidi_sequencer.cpp. References num_tracks, and track_processors.
00605 {
00606 for(int i=0; i<num_tracks; ++i )
00607 {
00608 delete track_processors[i];
00609 }
00610 }
|
|
|
Definition at line 652 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_beat, and state.
00653 {
00654 return state.cur_beat;
00655 }
|
|
|
Definition at line 658 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_measure, and state.
00659 {
00660 return state.cur_measure;
00661 }
|
|
|
Definition at line 642 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDIClockTime, and state.
00643 {
00644 return state.cur_clock;
00645 }
|
|
|
Definition at line 668 of file jdkmidi_sequencer.cpp. References state, jdkmidi::MIDISequencerTrackState::tempobpm, and jdkmidi::MIDISequencerState::track_state.
00669 {
00670 return state.track_state[0]->tempobpm;
00671 }
|
|
|
Definition at line 663 of file jdkmidi_sequencer.cpp. References tempo_scale.
00664 {
00665 return ((double)tempo_scale)*0.01;
00666 }
|
|
|
Definition at line 647 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_time_ms, and state.
00648 {
00649 return state.cur_time_ms;
00650 }
|
|
||||||||||||
|
Definition at line 1016 of file jdkmidi_sequencer.cpp. References beat_marker_msg, jdkmidi::MIDISequencerState::cur_beat, jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDISequencerState::cur_measure, jdkmidi::MIDISequencerState::cur_time_ms, jdkmidi::MIDIMultiTrack::GetClksPerBeat(), jdkmidi::MIDIMultiTrackIterator::GetCurEvent(), jdkmidi::MIDIMultiTrackIterator::GetCurEventTime(), GetNextEventTime(), GetNextEventTimeMs(), jdkmidi::MIDIMultiTrackIterator::GoToNextEvent(), jdkmidi::MIDISequencerState::iterator, jdkmidi::MIDIClockTime, jdkmidi::MIDISequencerState::multitrack, jdkmidi::MIDISequencerState::next_beat_time, jdkmidi::MIDISequencerState::notifier, jdkmidi::MIDISequencerGUIEventNotifier::Notify(), jdkmidi::MIDISequencerTrackProcessor::Process(), jdkmidi::MIDISequencerTrackState::Process(), jdkmidi::MIDIMessage::SetBeatMarker(), jdkmidi::MIDIMessage::SetNoOp(), jdkmidi::MIDITimedBigMessage::SetTime(), jdkmidi::MIDISequencerTrackProcessor::solo, solo_mode, state, jdkmidi::MIDISequencerTrackState::timesig_denominator, jdkmidi::MIDISequencerTrackState::timesig_numerator, track_processors, and jdkmidi::MIDISequencerState::track_state.
01017 {
01018 MIDIClockTime t;
01019
01020
01021 // ask the iterator for the current event time
01022 if( state.iterator.GetCurEventTime(&t) )
01023 {
01024 // move current time forward one event
01025
01026 MIDIClockTime new_clock;
01027 float new_time_ms;
01028
01029 GetNextEventTime( &new_clock );
01030 GetNextEventTimeMs( &new_time_ms );
01031
01032 // must set cur_clock AFTER GetnextEventTimeMs() is called
01033 // since GetNextEventTimeMs() uses cur_clock to calculate
01034
01035 state.cur_clock = new_clock;
01036 state.cur_time_ms = new_time_ms;
01037
01038
01039 // is the next beat marker before this event?
01040
01041 if( state.next_beat_time<=t )
01042 {
01043 // yes, this is a beat event now.
01044
01045 // say this event came on track 0, the conductor track
01046 *tracknum = 0;
01047
01048 // put current info into beat marker message
01049 beat_marker_msg.SetBeatMarker();
01050 beat_marker_msg.SetTime( state.next_beat_time );
01051 *msg = beat_marker_msg;
01052
01053 // update our beat count
01054
01055 int new_beat = state.cur_beat+1;
01056 int new_measure = state.cur_measure;
01057
01058 // do we need to update the measure number?
01059
01060 if( new_beat>=state.track_state[0]->timesig_numerator )
01061 {
01062 // yup
01063
01064 new_beat=0;
01065 ++new_measure;
01066 }
01067
01068 // update our next beat time
01069
01070
01071 // denom=4 (16) ---> 4/16 midi file beats per symbolic beat
01072 // denom=3 (8) ---> 4/8 midi file beats per symbolic beat
01073 // denom=2 (4) ---> 4/4 midi file beat per symbolic beat
01074 // denom=1 (2) ---> 4/2 midi file beats per symbolic beat
01075 // denom=0 (1) ---> 4/1 midi file beats per symbolic beat
01076
01077 state.next_beat_time +=
01078 state.multitrack->GetClksPerBeat()
01079 * 4 / (state.track_state[0]->timesig_denominator);
01080
01081 state.cur_beat = new_beat;
01082 state.cur_measure = new_measure;
01083
01084 // now notify the GUI that the beat number changed
01085 state.notifier->Notify(
01086 this,
01087 MIDISequencerGUIEvent(
01088 MIDISequencerGUIEvent::GROUP_TRANSPORT,
01089 0,
01090 MIDISequencerGUIEvent::GROUP_TRANSPORT_BEAT
01091 )
01092 );
01093
01094 // if the new beat number is 0 then the measure changed too
01095 if( state.cur_beat==0 )
01096 {
01097 state.notifier->Notify(
01098 this,
01099 MIDISequencerGUIEvent(
01100 MIDISequencerGUIEvent::GROUP_TRANSPORT,
01101 0,
01102 MIDISequencerGUIEvent::GROUP_TRANSPORT_MEASURE
01103 )
01104 );
01105 }
01106
01107 // give the beat marker event to the conductor track to process
01108 state.track_state[*tracknum]->Process(msg);
01109
01110
01111 return true;
01112 }
01113 else // this event comes before the next beat
01114 {
01115 MIDITimedBigMessage *msg_ptr;
01116
01117 if( state.iterator.GetCurEvent( tracknum, &msg_ptr ) )
01118 {
01119 int trk=*tracknum;
01120
01121 // copy the event so Process can modify it
01122
01123 *msg = *msg_ptr;
01124
01125 bool allow_msg=true;
01126
01127 // are we in solo mode?
01128
01129 if( solo_mode )
01130 {
01131 // yes, only allow this message thru if
01132 // the track is either track 0
01133 // or it is explicitly solod.
01134
01135 if( trk==0 || track_processors[trk]->solo )
01136 {
01137 allow_msg=true;
01138 }
01139 else
01140 {
01141 allow_msg=false;
01142 }
01143
01144 }
01145
01146
01147 if( !(allow_msg
01148 && track_processors[trk]->Process(msg)
01149 && state.track_state[trk]->Process(msg))
01150 )
01151 {
01152 // the message is not allowed to come out!
01153 // erase it
01154 msg->SetNoOp();
01155 }
01156
01157 // go to the next event on the multitrack
01158 state.iterator.GoToNextEvent();
01159
01160 return true;
01161
01162 }
01163 }
01164 }
01165
01166 return false;
01167 }
|
|
|
Definition at line 995 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDIMultiTrackIterator::GetCurEventTime(), jdkmidi::MIDISequencerState::iterator, jdkmidi::MIDIClockTime, jdkmidi::MIDISequencerState::next_beat_time, and state.
00996 {
00997 // ask the iterator for the current event time
00998 bool f = state.iterator.GetCurEventTime(t);
00999
01000 if( f )
01001 {
01002 // if we have an event in the future, check to see if it is
01003 // further in time than the next beat marker
01004
01005 if( (*t) >= state.next_beat_time )
01006 {
01007 // ok, the next event is a beat - return the next beat time
01008
01009 *t = state.next_beat_time;
01010 }
01011 }
01012
01013 return f;
01014 }
|
|
|
Definition at line 957 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDISequencerState::cur_time_ms, jdkmidi::MIDIMultiTrack::GetClksPerBeat(), GetNextEventTime(), jdkmidi::MIDIClockTime, jdkmidi::MIDISequencerState::multitrack, state, tempo_scale, jdkmidi::MIDISequencerTrackState::tempobpm, and jdkmidi::MIDISequencerState::track_state.
00958 {
00959 MIDIClockTime ct;
00960 bool f = GetNextEventTime( &ct );
00961
00962 if( f )
00963 {
00964 // calculate delta time from last event time
00965
00966 double delta_clocks = (double)(ct - state.cur_clock);
00967
00968 // calculate tempo in milliseconds per clock
00969
00970 double clocks_per_sec = ((state.track_state[0]->tempobpm *
00971 (((double)tempo_scale)*0.01)
00972 * (1.0f/60.0f)) * state.multitrack->GetClksPerBeat());
00973
00974 if( clocks_per_sec>0 )
00975 {
00976 float ms_per_clock = 1000.0f /clocks_per_sec;
00977
00978 // calculate delta time in milliseconds
00979
00980 float delta_ms = float(delta_clocks * ms_per_clock);
00981
00982 // return it added with the current time in ms.
00983
00984 *t = delta_ms + state.cur_time_ms;
00985 }
00986 else
00987 {
00988 f=false;
00989 }
00990 }
00991
00992 return f;
00993 }
|
|
|
Definition at line 305 of file sequencer.h. References jdkmidi::MIDISequencerState::num_tracks, and state.
00305 { return state.num_tracks; }
|
|
|
Definition at line 693 of file jdkmidi_sequencer.cpp. References solo_mode.
00694 {
00695 return solo_mode;
00696 }
|
|
|
Definition at line 632 of file jdkmidi_sequencer.cpp. References state.
00633 {
00634 return &state;
00635 }
|
|
|
Definition at line 627 of file jdkmidi_sequencer.cpp. References state.
00628 {
00629 return &state;
00630 }
|
|
|
Definition at line 688 of file jdkmidi_sequencer.cpp. References track_processors.
00689 {
00690 return track_processors[ trk ];
00691 }
|
|
|
Definition at line 683 of file jdkmidi_sequencer.cpp. References track_processors.
00684 {
00685 return track_processors[trk];
00686 }
|
|
|
Definition at line 678 of file jdkmidi_sequencer.cpp. References state, and jdkmidi::MIDISequencerState::track_state.
00679 {
00680 return state.track_state[ trk ];
00681 }
|
|
|
Definition at line 673 of file jdkmidi_sequencer.cpp. References state, and jdkmidi::MIDISequencerState::track_state.
00674 {
00675 return state.track_state[trk];
00676 }
|
|
||||||||||||
|
Definition at line 880 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_beat, jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDISequencerState::cur_measure, jdkmidi::MIDISequencerState::cur_time_ms, jdkmidi::MIDIMultiTrack::GetClksPerBeat(), jdkmidi::MIDISequencerGUIEventNotifier::GetEnable(), GetNextEvent(), GetNextEventTime(), jdkmidi::MIDIMultiTrackIterator::GoToTime(), jdkmidi::MIDISequencerTrackState::GoToZero(), jdkmidi::MIDISequencerState::iterator, jdkmidi::MIDIClockTime, jdkmidi::MIDISequencerState::multitrack, jdkmidi::MIDISequencerState::next_beat_time, jdkmidi::MIDISequencerState::notifier, jdkmidi::MIDISequencerGUIEventNotifier::Notify(), jdkmidi::MIDISequencerState::num_tracks, ScanEventsAtThisTime(), jdkmidi::MIDISequencerGUIEventNotifier::SetEnable(), state, jdkmidi::MIDISequencerTrackState::timesig_denominator, and jdkmidi::MIDISequencerState::track_state.
00881 {
00882 // temporarily disable the gui notifier
00883
00884 bool notifier_mode=false;
00885 if( state.notifier )
00886 {
00887 notifier_mode = state.notifier->GetEnable();
00888 state.notifier->SetEnable(false);
00889 }
00890
00891 if( measure < state.cur_measure || measure==0 )
00892 {
00893 for( int i=0; i<state.num_tracks; ++i )
00894 {
00895 state.track_state[i]->GoToZero();
00896 }
00897
00898 state.iterator.GoToTime( 0 );
00899
00900 state.cur_time_ms = 0.0;
00901 state.cur_clock = 0;
00902 state.cur_beat = 0;
00903 state.cur_measure = 0;
00904 // state.next_beat_time = state.multitrack->GetClksPerBeat();
00905 state.next_beat_time =
00906 state.multitrack->GetClksPerBeat()
00907 * 4 / (state.track_state[0]->timesig_denominator);
00908
00909 }
00910
00911 MIDIClockTime t=0;
00912 int trk;
00913 MIDITimedBigMessage ev;
00914
00915 // iterate thru all the events until cur-measure and cur_beat are
00916 // where we want them.
00917
00918 while(
00919 GetNextEventTime( &t )
00920 && GetNextEvent(&trk,&ev)
00921 && state.cur_measure<=measure
00922 )
00923 {
00924 if( state.cur_measure==measure && state.cur_beat>=beat )
00925 {
00926 break;
00927 }
00928 }
00929
00930
00931 // examine all the events at this specific time
00932 // and update the track states to reflect this time
00933
00934
00935 ScanEventsAtThisTime();
00936
00937
00938
00939 // re-enable the gui notifier if it was enabled previously
00940 if( state.notifier )
00941 {
00942 state.notifier->SetEnable( notifier_mode );
00943
00944 // cause a full gui refresh now
00945
00946 state.notifier->Notify( this, MIDISequencerGUIEvent::GROUP_ALL );
00947 }
00948
00949 // return true if we actually found the measure requested
00950
00951 return state.cur_measure == measure && state.cur_beat == beat;
00952
00953 }
|
|
|
Definition at line 747 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_beat, jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDISequencerState::cur_measure, jdkmidi::MIDISequencerState::cur_time_ms, jdkmidi::MIDIMultiTrack::GetClksPerBeat(), jdkmidi::MIDISequencerGUIEventNotifier::GetEnable(), GetNextEvent(), GetNextEventTime(), jdkmidi::MIDIMultiTrackIterator::GoToTime(), jdkmidi::MIDISequencerTrackState::GoToZero(), jdkmidi::MIDISequencerState::iterator, jdkmidi::MIDIClockTime, jdkmidi::MIDISequencerState::multitrack, jdkmidi::MIDISequencerState::next_beat_time, jdkmidi::MIDISequencerState::notifier, jdkmidi::MIDISequencerGUIEventNotifier::Notify(), jdkmidi::MIDISequencerState::num_tracks, ScanEventsAtThisTime(), jdkmidi::MIDISequencerGUIEventNotifier::SetEnable(), state, jdkmidi::MIDISequencerTrackState::timesig_denominator, and jdkmidi::MIDISequencerState::track_state.
00748 {
00749 // temporarily disable the gui notifier
00750
00751 bool notifier_mode=false;
00752 if( state.notifier )
00753 {
00754 notifier_mode = state.notifier->GetEnable();
00755 state.notifier->SetEnable(false);
00756 }
00757
00758 if( time_clk < state.cur_clock || time_clk==0 )
00759 {
00760 // start from zero if desired time is before where we are
00761 for( int i=0; i<state.num_tracks; ++i )
00762 {
00763 state.track_state[i]->GoToZero();
00764 }
00765
00766 state.iterator.GoToTime( 0 );
00767
00768 state.cur_time_ms = 0.0;
00769 state.cur_clock = 0;
00770 // state.next_beat_time = state.multitrack->GetClksPerBeat();
00771 state.next_beat_time =
00772 state.multitrack->GetClksPerBeat()
00773 * 4 / (state.track_state[0]->timesig_denominator);
00774
00775 state.cur_beat = 0;
00776 state.cur_measure = 0;
00777
00778 }
00779
00780 MIDIClockTime t=0;
00781 int trk;
00782 MIDITimedBigMessage ev;
00783
00784 while(
00785 GetNextEventTime( &t )
00786 && t<time_clk
00787 && GetNextEvent(&trk,&ev)
00788 )
00789 {
00790 ;
00791 }
00792
00793
00794 // examine all the events at this specific time
00795 // and update the track states to reflect this time
00796
00797 ScanEventsAtThisTime();
00798
00799 // re-enable the gui notifier if it was enabled previously
00800 if( state.notifier )
00801 {
00802 state.notifier->SetEnable( notifier_mode );
00803
00804 // cause a full gui refresh now
00805
00806 state.notifier->Notify( this, MIDISequencerGUIEvent::GROUP_ALL );
00807 }
00808
00809
00810
00811 return true;
00812
00813 }
|
|
|
Definition at line 815 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_beat, jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDISequencerState::cur_measure, jdkmidi::MIDISequencerState::cur_time_ms, jdkmidi::MIDIMultiTrack::GetClksPerBeat(), jdkmidi::MIDISequencerGUIEventNotifier::GetEnable(), GetNextEvent(), GetNextEventTimeMs(), jdkmidi::MIDIMultiTrackIterator::GoToTime(), jdkmidi::MIDISequencerTrackState::GoToZero(), jdkmidi::MIDISequencerState::iterator, jdkmidi::MIDISequencerState::multitrack, jdkmidi::MIDISequencerState::next_beat_time, jdkmidi::MIDISequencerState::notifier, jdkmidi::MIDISequencerGUIEventNotifier::Notify(), jdkmidi::MIDISequencerState::num_tracks, jdkmidi::MIDISequencerGUIEventNotifier::SetEnable(), state, jdkmidi::MIDISequencerTrackState::timesig_denominator, and jdkmidi::MIDISequencerState::track_state.
00816 {
00817 // temporarily disable the gui notifier
00818
00819 bool notifier_mode=false;
00820 if( state.notifier )
00821 {
00822 notifier_mode = state.notifier->GetEnable();
00823 state.notifier->SetEnable(false);
00824 }
00825
00826 if( time_ms < state.cur_time_ms || time_ms==0.0 )
00827 {
00828 // start from zero if desired time is before where we are
00829 for( int i=0; i<state.num_tracks; ++i )
00830 {
00831 state.track_state[i]->GoToZero();
00832 }
00833
00834 state.iterator.GoToTime( 0 );
00835
00836 state.cur_time_ms = 0.0;
00837 state.cur_clock = 0;
00838 // state.next_beat_time = state.multitrack->GetClksPerBeat();
00839 state.next_beat_time =
00840 state.multitrack->GetClksPerBeat()
00841 * 4 / (state.track_state[0]->timesig_denominator);
00842
00843 state.cur_beat = 0;
00844 state.cur_measure = 0;
00845 }
00846
00847 float t=0;
00848 int trk;
00849 MIDITimedBigMessage ev;
00850
00851 while(
00852 GetNextEventTimeMs( &t )
00853 && t<time_ms
00854 && GetNextEvent(&trk,&ev)
00855 )
00856 {
00857 ;
00858 }
00859
00860 // examine all the events at this specific time
00861 // and update the track states to reflect this time
00862
00863 // ScanEventsAtThisTime();
00864
00865 // re-enable the gui notifier if it was enabled previously
00866 if( state.notifier )
00867 {
00868 state.notifier->SetEnable( notifier_mode );
00869
00870 // cause a full gui refresh now
00871
00872 state.notifier->Notify( this, MIDISequencerGUIEvent::GROUP_ALL );
00873 }
00874
00875
00876 return true;
00877
00878 }
|
|
|
Definition at line 722 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDISequencerState::cur_time_ms, jdkmidi::MIDIMultiTrack::GetClksPerBeat(), jdkmidi::MIDIMultiTrackIterator::GoToTime(), jdkmidi::MIDISequencerTrackState::GoToZero(), jdkmidi::MIDISequencerState::iterator, jdkmidi::MIDISequencerState::multitrack, jdkmidi::MIDISequencerState::next_beat_time, num_tracks, ScanEventsAtThisTime(), state, jdkmidi::MIDISequencerTrackState::timesig_denominator, and jdkmidi::MIDISequencerState::track_state.
00723 {
00724 // go to time zero
00725
00726 for( int i=0; i<num_tracks; ++i )
00727 {
00728 state.track_state[i]->GoToZero();
00729 }
00730
00731 state.iterator.GoToTime( 0 );
00732
00733 state.cur_time_ms = 0.0;
00734 state.cur_clock = 0;
00735
00736 // state.next_beat_time = state.multitrack->GetClksPerBeat();
00737 state.next_beat_time =
00738 state.multitrack->GetClksPerBeat()
00739 * 4 / (state.track_state[0]->timesig_denominator);
00740
00741 // examine all the events at this specific time
00742 // and update the track states to reflect this time
00743
00744 ScanEventsAtThisTime();
00745 }
|
|
|
Definition at line 618 of file jdkmidi_sequencer.cpp. References num_tracks, jdkmidi::MIDISequencerTrackProcessor::Reset(), jdkmidi::MIDISequencerTrackState::Reset(), state, track_processors, and jdkmidi::MIDISequencerState::track_state.
00619 {
00620 for( int i=0; i<num_tracks; ++i )
00621 {
00622 state.track_state[i]->Reset();
00623 track_processors[i]->Reset();
00624 }
00625 }
|
|
|
Definition at line 612 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerTrackProcessor::Reset(), jdkmidi::MIDISequencerTrackState::Reset(), state, track_processors, and jdkmidi::MIDISequencerState::track_state.
00613 {
00614 state.track_state[trk]->Reset();
00615 track_processors[trk]->Reset();
00616 }
|
|
|
Definition at line 1169 of file jdkmidi_sequencer.cpp. References jdkmidi::MIDISequencerState::cur_beat, jdkmidi::MIDISequencerState::cur_clock, jdkmidi::MIDISequencerState::cur_measure, jdkmidi::MIDISequencerState::cur_time_ms, GetNextEvent(), GetNextEventTime(), jdkmidi::MIDIMultiTrackIterator::GetState(), jdkmidi::MIDISequencerState::iterator, jdkmidi::MIDIClockTime, jdkmidi::MIDIMultiTrackIterator::SetState(), and state.
01170 {
01171 // save the current iterator state
01172
01173 MIDIMultiTrackIteratorState istate( state.iterator.GetState() );
01174 int prev_measure = state.cur_measure;
01175 int prev_beat = state.cur_beat;
01176
01177
01178 // process all messages up to and including this time only
01179
01180 MIDIClockTime orig_clock = state.cur_clock;
01181 double orig_time_ms = state.cur_time_ms;
01182
01183
01184 MIDIClockTime t=0;
01185 int trk;
01186 MIDITimedBigMessage ev;
01187
01188 while(
01189 GetNextEventTime( &t )
01190 && t==orig_clock
01191 && GetNextEvent(&trk,&ev)
01192 )
01193 {
01194 ;
01195 }
01196
01197 // restore the iterator state
01198 state.iterator.SetState( istate );
01199
01200 // and current time
01201 state.cur_clock = orig_clock;
01202 state.cur_time_ms = float(orig_time_ms);
01203
01204 state.cur_measure=prev_measure;
01205 state.cur_beat = prev_beat;
01206
01207 }
|
|
|
Definition at line 698 of file jdkmidi_sequencer.cpp. References tempo_scale.
00699 {
00700 tempo_scale = (int)(scale*100);
00701 }
|
|
||||||||||||
|
Definition at line 703 of file jdkmidi_sequencer.cpp. References num_tracks, jdkmidi::MIDISequencerTrackProcessor::solo, solo_mode, and track_processors.
00704 {
00705 int i;
00706 solo_mode = m;
00707
00708 for( i=0; i<num_tracks; ++i )
00709 {
00710 if( i==trk )
00711 {
00712 track_processors[i]->solo = true;
00713 }
00714 else
00715 {
00716 track_processors[i]->solo = false;
00717 }
00718 }
00719
00720 }
|
|
|
Definition at line 637 of file jdkmidi_sequencer.cpp. References state.
00638 {
00639 state = *s;
00640 }
|
|
|
Definition at line 325 of file sequencer.h. |
|
|
Definition at line 330 of file sequencer.h. |
|
|
Definition at line 327 of file sequencer.h. |
|
|
Definition at line 333 of file sequencer.h. |
|
|
Definition at line 328 of file sequencer.h. |
|
|
Definition at line 331 of file sequencer.h. |