src/camidion/chordhelper/music/ChordProgression.java

   1 package camidion.chordhelper.music;
   2
   3 import java.util.Vector;
   4 import java.util.regex.Pattern;
   5
   6 import javax.sound.midi.InvalidMidiDataException;
   7 import javax.sound.midi.Sequence;
   8
   9 /**
  10  * Chord Progression - コード進行のクラス
  11  */
  12 public class ChordProgression {
  13
  14         public class TickRange implements Cloneable {
  15                 long startTickPos = 0, end_tick_pos = 0;
  16                 public TickRange( long tick_pos ) {
  17                         end_tick_pos = startTickPos = tick_pos;
  18                 }
  19                 public TickRange( long start_tick_pos, long end_tick_pos ) {
  20                         this.startTickPos = start_tick_pos;
  21                         this.end_tick_pos = end_tick_pos;
  22                 }
  23                 protected TickRange clone() {
  24                         return new TickRange( startTickPos, end_tick_pos );
  25                 }
  26                 public void moveForward() {
  27                         startTickPos = end_tick_pos;
  28                 }
  29                 public void moveForward( long duration ) {
  30                         startTickPos = end_tick_pos;
  31                         end_tick_pos += duration;
  32                 }
  33                 public long duration() {
  34                         return end_tick_pos - startTickPos;
  35                 }
  36                 public boolean contains( long tick ) {
  37                         return ( tick >= startTickPos && tick < end_tick_pos );
  38                 }
  39         }
  40
  41         class ChordStroke {
  42                 Chord chord; int beat_length; TickRange tickRange = null;
  43                 public ChordStroke(Chord chord) { this( chord, 1 ); }
  44                 public ChordStroke(Chord chord, int beat_length) {
  45                         this.chord = chord;
  46                         this.beat_length = beat_length;
  47                 }
  48                 public String toString() {
  49                         String str = chord.toString();
  50                         for( int i=2; i <= beat_length; i++ ) str += " %";
  51                         return str;
  52                 }
  53         }
  54
  55         // 時間位置付き歌詞
  56         public class Lyrics {
  57                 String text = null;
  58                 Long startTickPos = null;
  59                 public Lyrics(String text) { this.text = text; }
  60                 public Lyrics(String text, long tick_pos) {
  61                         this.text = text; startTickPos = tick_pos;
  62                 }
  63                 public String toString() { return text; }
  64         }
  65
  66         class Measure extends Vector<Object> {
  67                 Long ticks_per_beat = null;
  68                 public int numberOfBeats() {
  69                         int n = 0;
  70                         for( Object obj : this ) {
  71                                 if( obj instanceof ChordStroke ) {
  72                                         n += ((ChordStroke)obj).beat_length;
  73                                 }
  74                         }
  75                         return n;
  76                 }
  77                 // 小節内のコードストロークが時間的に等間隔かどうか調べる。
  78                 // もし等間隔の場合、テキスト出力時に % をつける必要がなくなる。
  79                 public boolean isEquallyDivided() {
  80                         int l, l_prev = 0;
  81                         for( Object obj : this ) {
  82                                 if( obj instanceof ChordStroke ) {
  83                                         l = ((ChordStroke)obj).beat_length;
  84                                         if( l_prev > 0 && l_prev != l ) {
  85                                                 return false;
  86                                         }
  87                                         l_prev = l;
  88                                 }
  89                         }
  90                         return true;
  91                 }
  92                 public int addBeat() { return addBeat(1); }
  93                 public int addBeat(int num_beats) {
  94                         ChordStroke last_chord_stroke = null;
  95                         for( Object obj : this ) {
  96                                 if( obj instanceof ChordStroke ) {
  97                                         last_chord_stroke = (ChordStroke)obj;
  98                                 }
  99                         }
 100                         if( last_chord_stroke == null ) {
 101                                 return 0;
 102                         }
 103                         return last_chord_stroke.beat_length += num_beats;
 104                 }
 105                 public String toString() {
 106                         String str = "";
 107                         boolean is_eq_dev = isEquallyDivided();
 108                         for( Object element : this ) {
 109                                 str += " ";
 110                                 if( element instanceof ChordStroke ) {
 111                                         ChordStroke cs = (ChordStroke)element;
 112                                         str += is_eq_dev ? cs.chord : cs;
 113                                 }
 114                                 else if( element instanceof Lyrics ) {
 115                                         str += element.toString();
 116                                 }
 117                         }
 118                         return str;
 119                 }
 120                 public TickRange getRange() {
 121                         long start_tick_pos = -1;
 122                         long end_tick_pos = -1;
 123                         for( Object element : this ) {
 124                                 if( ! (element instanceof ChordProgression.ChordStroke) )
 125                                         continue;
 126                                 ChordProgression.ChordStroke chord_stroke
 127                                 = (ChordProgression.ChordStroke)element;
 128                                 // 小節の先頭と末尾の tick を求める
 129                                 if( start_tick_pos < 0 ) {
 130                                         start_tick_pos = chord_stroke.tickRange.startTickPos;
 131                                 }
 132                                 end_tick_pos = chord_stroke.tickRange.end_tick_pos;
 133                         }
 134                         if( start_tick_pos < 0 || end_tick_pos < 0 ) {
 135                                 return null;
 136                         }
 137                         return new TickRange( start_tick_pos, end_tick_pos );
 138                 }
 139                 public ChordStroke chordStrokeAt( long tick ) {
 140                         for( Object element : this ) {
 141                                 if( ! (element instanceof ChordProgression.ChordStroke) )
 142                                         continue;
 143                                 ChordProgression.ChordStroke chord_stroke
 144                                 = (ChordProgression.ChordStroke)element;
 145                                 if( chord_stroke.tickRange.contains(tick) ) {
 146                                         return chord_stroke;
 147                                 }
 148                         }
 149                         return null;
 150                 }
 151         }
 152         class Line extends Vector<Measure> {
 153                 public String toString() {
 154                         String str = "";
 155                         for( Measure measure : this ) str += measure + "|";
 156                         return str;
 157                 }
 158         }
 159
 160         // 内部変数
 161         Vector<Line> lines = null;
 162         Key key = null;
 163         private Long ticks_per_measure = null;
 164
 165         public Key getKey() { return key; }
 166         public void setKey(Key key) { this.key = key; }
 167
 168         public String toString() {
 169                 String str = "";
 170                 if( key != null ) str += "Key: " + key + "\n";
 171                 for( Line line : lines ) str += line + "\n";
 172                 return str;
 173         }
 174
 175         /**
 176          * デフォルトの設定でコード進行を構築します。
 177          */
 178         public ChordProgression() { }
 179         /**
 180          * 指定された小節数、キー、拍子に合わせたコード進行を構築します。
 181          * コード進行の内容は、ランダムに自動生成されます。
 182          * @param measureLength 小節の長さ
 183          * @param timeSignatureUpper 拍子の分子
 184          */
 185         public ChordProgression( int measureLength, int timeSignatureUpper ) {
 186                 int key_co5 = (int)(Math.random() * 12) - 5;
 187                 key = new Key(key_co5, Key.MajorMinor.MAJOR);
 188                 lines = new Vector<Line>();
 189                 Line line = new Line();
 190                 boolean is_end;
 191                 Chord chord, prev_chord = new Chord(new NoteSymbol(key_co5));
 192                 int co5_offset, prev_co5_offset;
 193                 double r;
 194                 for( int mp=0; mp<measureLength; mp++ ) {
 195                         is_end = (mp == 0 || mp == measureLength - 1); // 最初または最後の小節かを覚えておく
 196                         Measure measure = new Measure();
 197                         ChordStroke lastChordStroke = null;
 198                         for( int i=0; i<timeSignatureUpper; i++ ) {
 199                                 if(
 200                                         i % 4 == 2 && Math.random() < 0.8
 201                                         ||
 202                                         i % 2 != 0 && Math.random() < 0.9
 203                                 ){
 204                                         // もう一拍延長
 205                                         lastChordStroke.beat_length++;
 206                                         continue;
 207                                 }
 208                                 chord = new Chord(new NoteSymbol(key_co5));
 209                                 co5_offset = 0;
 210                                 prev_co5_offset = prev_chord.rootNoteSymbol().toCo5() - key_co5;
 211                                 if( ! is_end ) {
 212                                         //
 213                                         // 最初または最後の小節は常にトニックにする。
 214                                         // 完全五度ずつ下がる進行を基本としつつ、時々そうでない進行も出現するようにする。
 215                                         // サブドミナントを超えるとスケールを外れるので、超えそうになったらランダムに決め直す。
 216                                         //
 217                                         r = Math.random();
 218                                         co5_offset = prev_co5_offset - 1;
 219                                         if( co5_offset < -1 || (prev_co5_offset < 5 && r < 0.5) ) {
 220                                                 //
 221                                                 // 長７度がルートとなるコードの出現確率を半減させながらコードを決める
 222                                                 // （余りが６のときだけが長７度）
 223                                                 // なお、前回と同じコードは使わないようにする。
 224                                                 do {
 225                                                         co5_offset = (int)(Math.random() * 13) % 7 - 1;
 226                                                 } while( co5_offset == prev_co5_offset );
 227                                         }
 228                                         int co5RootNote = key_co5 + co5_offset;
 229                                         chord.setRoot(new NoteSymbol(co5RootNote));
 230                                         chord.setBass(new NoteSymbol(co5RootNote));
 231                                 }
 232                                 switch( co5_offset ) {
 233                                 // ルート音ごとに、7th などの付加や、メジャーマイナー反転を行う確率を決める
 234                                 case 5: // VII
 235                                         if( Math.random() < 0.5 ) {
 236                                                 // m7-5
 237                                                 chord.set(Chord.Interval.MINOR);
 238                                                 chord.set(Chord.Interval.FLAT5);
 239                                         }
 240                                         if( Math.random() < 0.8 )
 241                                                 chord.set(Chord.Interval.SEVENTH);
 242                                         break;
 243                                 case 4: // Secondary dominant (III)
 244                                         if( prev_co5_offset == 5 ) {
 245                                                 // ルートが長７度→長３度の進行のとき、反転確率を上げる。
 246                                                 // （ハ長調でいう Bm7-5 の次に E7 を出現しやすくする）
 247                                                 if( Math.random() < 0.2 ) chord.set(Chord.Interval.MINOR);
 248                                         }
 249                                         else {
 250                                                 if( Math.random() < 0.8 ) chord.set(Chord.Interval.MINOR);
 251                                         }
 252                                         if( Math.random() < 0.7 ) chord.set(Chord.Interval.SEVENTH);
 253                                         break;
 254                                 case 3: // VI
 255                                         if( Math.random() < 0.8 ) chord.set(Chord.Interval.MINOR);
 256                                         if( Math.random() < 0.7 ) chord.set(Chord.Interval.SEVENTH);
 257                                         break;
 258                                 case 2: // II
 259                                         if( Math.random() < 0.8 ) chord.set(Chord.Interval.MINOR);
 260                                         if( Math.random() < 0.7 ) chord.set(Chord.Interval.SEVENTH);
 261                                         break;
 262                                 case 1: // Dominant (V)
 263                                         if( Math.random() < 0.1 ) chord.set(Chord.Interval.MINOR);
 264                                         if( Math.random() < 0.3 ) chord.set(Chord.Interval.SEVENTH);
 265                                         if( Math.random() < 0.2 ) chord.set(Chord.Interval.NINTH);
 266                                         break;
 267                                 case 0: // Tonic（ここでマイナーで終わるとさみしいので setMinorThird() はしない）
 268                                         if( Math.random() < 0.2 ) chord.set(Chord.Interval.MAJOR_SEVENTH);
 269                                         if( Math.random() < 0.2 ) chord.set(Chord.Interval.NINTH);
 270                                         break;
 271                                 case -1: // Sub-dominant (IV)
 272                                         if( Math.random() < 0.1 ) {
 273                                                 chord.set(Chord.Interval.MINOR);
 274                                                 if( Math.random() < 0.3 ) chord.set(Chord.Interval.SEVENTH);
 275                                         }
 276                                         else
 277                                                 if( Math.random() < 0.2 ) chord.set(Chord.Interval.MAJOR_SEVENTH);
 278                                         if( Math.random() < 0.2 ) chord.set(Chord.Interval.NINTH);
 279                                         break;
 280                                 }
 281                                 measure.add( lastChordStroke = new ChordStroke(chord) );
 282                                 prev_chord = chord;
 283                         }
 284                         line.add(measure);
 285                         if( (mp+1) % 8 == 0 ) { // ８小節おきに改行
 286                                 lines.add(line);
 287                                 line = new Line();
 288                         }
 289                 }
 290                 if( line.size() > 0 ) lines.add(line);
 291         }
 292         // テキストからコード進行を生成
 293         public ChordProgression( String source_text ) {
 294                 if( source_text == null ) return;
 295                 Measure measure;
 296                 Line line;
 297                 String[] linesSrc, measuresSrc, elementsSrc;
 298                 Chord lastChord = null;
 299                 String keyHeaderRegex = "^Key(\\s*):(\\s*)";
 300                 String keyValueRegex = "[A-G]+.*$";
 301                 //
 302                 // キーであるかどうか見分けるためのパターン
 303                 Pattern keyMatchPattern = Pattern.compile(
 304                         keyHeaderRegex + keyValueRegex,
 305                         Pattern.CASE_INSENSITIVE
 306                 );
 307                 // キーのヘッダーを取り除くためのパターン
 308                 Pattern keyReplPattern = Pattern.compile(
 309                         keyHeaderRegex, Pattern.CASE_INSENSITIVE
 310                 );
 311                 //
 312                 linesSrc = source_text.split("[\r\n]+");
 313                 lines = new Vector<Line>();
 314                 for( String line_src : linesSrc ) {
 315                         measuresSrc = line_src.split("\\|");
 316                         if( measuresSrc.length > 0 ) {
 317                                 String keyString = measuresSrc[0].trim();
 318                                 if( keyMatchPattern.matcher(keyString).matches() ) {
 319                                         try {
 320                                                 key = new Key(keyReplPattern.matcher(keyString).replaceFirst(""));
 321                                                 continue;
 322                                         } catch( Exception e ) {
 323                                                 e.printStackTrace();
 324                                         }
 325                                 }
 326                         }
 327                         line = new Line();
 328                         for( String measureSrc : measuresSrc ) {
 329                                 elementsSrc = measureSrc.split("[ \t]+");
 330                                 measure = new Measure();
 331                                 for( String elementSrc : elementsSrc ) {
 332                                         if( elementSrc.isEmpty() ) continue;
 333                                         if( elementSrc.equals("%") ) {
 334                                                 if( measure.addBeat() == 0 ) {
 335                                                         measure.add( new ChordStroke(lastChord) );
 336                                                 }
 337                                                 continue;
 338                                         }
 339                                         try {
 340                                                 measure.add(new ChordStroke(lastChord = new Chord(elementSrc)));
 341                                         } catch( IllegalArgumentException ex ) {
 342                                                 measure.add( new Lyrics(elementSrc) );
 343                                         }
 344                                 }
 345                                 line.add(measure);
 346                         }
 347                         lines.add(line);
 348                 }
 349         }
 350
 351         // Major/minor 切り替え
 352         public void toggleKeyMajorMinor() {
 353                 key = key.createRelativeKey();
 354         }
 355
 356         // コード進行の移調
 357         public void transpose(int chromaticOffset) {
 358                 for( Line line : lines ) {
 359                         for( Measure measure : line ) {
 360                                 for( int i=0; i<measure.size(); i++ ) {
 361                                         Object element = measure.get(i);
 362                                         if( element instanceof ChordStroke ) {
 363                                                 ChordStroke cs = (ChordStroke)element;
 364                                                 Chord newChord = cs.chord.clone();
 365                                                 //
 366                                                 // キーが未設定のときは、最初のコードから推測して設定
 367                                                 if( key == null ) key = new Key(newChord);
 368                                                 //
 369                                                 newChord.transpose( chromaticOffset, key );
 370                                                 measure.set(i, new ChordStroke(newChord, cs.beat_length));
 371                                         }
 372                                 }
 373                         }
 374                 }
 375                 key.transpose(chromaticOffset);
 376         }
 377         // 異名同音の♭と＃を切り替える
 378         public void toggleEnharmonically() {
 379                 if( key == null ) return;
 380                 int original_key_co5 = key.toCo5();
 381                 int co5Offset = 0;
 382                 if( original_key_co5 > 4 ) {
 383                         co5Offset = -Music.SEMITONES_PER_OCTAVE;
 384                 }
 385                 else if( original_key_co5 < -4 ) {
 386                         co5Offset = Music.SEMITONES_PER_OCTAVE;
 387                 }
 388                 else {
 389                         return;
 390                 }
 391                 key.toggleEnharmonically();
 392                 for( Line line : lines ) {
 393                         for( Measure measure : line ) {
 394                                 for( int i=0; i<measure.size(); i++ ) {
 395                                         Object element = measure.get(i);
 396                                         if( element instanceof ChordStroke ) {
 397                                                 ChordStroke cs = (ChordStroke)element;
 398                                                 Chord newChord = cs.chord.clone();
 399                                                 newChord.setRoot(new NoteSymbol(newChord.rootNoteSymbol().toCo5() + co5Offset));
 400                                                 newChord.setBass(new NoteSymbol(newChord.bassNoteSymbol().toCo5() + co5Offset));
 401                                                 measure.set( i, new ChordStroke( newChord, cs.beat_length ) );
 402                                         }
 403                                 }
 404                         }
 405                 }
 406         }
 407         // コード進行の中に時間軸（MIDI tick）を書き込む
 408         //
 409         public void setTickPositions( FirstTrackSpec first_track ) {
 410                 ticks_per_measure = first_track.ticksPerMeasure;
 411                 TickRange tick_range = new TickRange(
 412                                 first_track.preMeasures * ticks_per_measure
 413                                 );
 414                 for( Line line : lines ) { // 行単位の処理
 415                         for( Measure measure : line ) { // 小節単位の処理
 416                                 int n_beats = measure.numberOfBeats();
 417                                 if( n_beats == 0 ) continue;
 418                                 long tpb = measure.ticks_per_beat = ticks_per_measure / n_beats ;
 419                                 for( Object element : measure ) {
 420                                         if( element instanceof Lyrics ) {
 421                                                 ((Lyrics)element).startTickPos = tick_range.startTickPos;
 422                                                 continue;
 423                                         }
 424                                         else if( element instanceof ChordStroke ) {
 425                                                 ChordStroke chord_stroke = (ChordStroke)element;
 426                                                 tick_range.moveForward( tpb * chord_stroke.beat_length );
 427                                                 chord_stroke.tickRange = tick_range.clone();
 428                                         }
 429                                 }
 430                         }
 431                 }
 432         }
 433         // コード文字列の書き込み
 434         public void setChordSymbolTextTo( AbstractTrackSpec ts ) {
 435                 for( Line line : lines ) {
 436                         for( Measure measure : line ) {
 437                                 if( measure.ticks_per_beat == null ) continue;
 438                                 for( Object element : measure ) {
 439                                         if( element instanceof ChordStroke ) {
 440                                                 ts.addStringTo( 0x01, (ChordStroke)element );
 441                                         }
 442                                 }
 443                         }
 444                 }
 445         }
 446         // 歌詞の書き込み
 447         public void setLyricsTo( AbstractTrackSpec ts ) {
 448                 for( Line line : lines ) {
 449                         for( Measure measure : line ) {
 450                                 if( measure.ticks_per_beat == null ) continue;
 451                                 for( Object element : measure ) {
 452                                         if( element instanceof Lyrics ) {
 453                                                 ts.addStringTo( 0x05, (Lyrics)element );
 454                                         }
 455                                 }
 456                         }
 457                 }
 458         }
 459         /**
 460          * コード進行をもとに MIDI シーケンスを生成します。
 461          * @return MIDIシーケンス
 462          */
 463         public Sequence toMidiSequence() {
 464                 return toMidiSequence(48);
 465         }
 466         /**
 467          * 指定のタイミング解像度で、
 468          * コード進行をもとに MIDI シーケンスを生成します。
 469          * @return MIDIシーケンス
 470          */
 471         public Sequence toMidiSequence(int ppq) {
 472                 //
 473                 // PPQ = Pulse Per Quarter (TPQN = Tick Per Quearter Note)
 474                 //
 475                 return toMidiSequence( ppq, 0, 0, null, null );
 476         }
 477         /**
 478          * 小節数、トラック仕様、コード進行をもとに MIDI シーケンスを生成します。
 479          * @param ppq 分解能（pulse per quarter）
 480          * @param startMeasure 開始小節位置
 481          * @param endMeasure 終了小節位置
 482          * @param firstTrack 最初のトラックの仕様
 483          * @param trackSpecs 残りのトラックの仕様
 484          * @return MIDIシーケンス
 485          */
 486         public Sequence toMidiSequence(
 487                 int ppq, int startMeasure, int endMeasure,
 488                 FirstTrackSpec firstTrack,
 489                 Vector<AbstractNoteTrackSpec> trackSpecs
 490         ) {
 491                 Sequence seq;
 492                 try {
 493                         seq = new Sequence(Sequence.PPQ, ppq);
 494                 } catch ( InvalidMidiDataException e ) {
 495                         e.printStackTrace();
 496                         return null;
 497                 }
 498                 // マスタートラックの生成
 499                 if( firstTrack == null ) {
 500                         firstTrack = new FirstTrackSpec();
 501                 }
 502                 firstTrack.key = this.key;
 503                 firstTrack.createTrack( seq, startMeasure, endMeasure );
 504                 //
 505                 // 中身がなければここで終了
 506                 if( lines == null || trackSpecs == null ) return seq;
 507                 //
 508                 // コード進行の中に時間軸（MIDI tick）を書き込む
 509                 setTickPositions(firstTrack);
 510                 //
 511                 // コードのテキストと歌詞を書き込む
 512                 setChordSymbolTextTo(firstTrack);
 513                 setLyricsTo(firstTrack);
 514                 //
 515                 // 残りのトラックを生成
 516                 for( AbstractNoteTrackSpec ts : trackSpecs ) {
 517                         ts.createTrack(seq, firstTrack);
 518                         if( ts instanceof DrumTrackSpec ) {
 519                                 ((DrumTrackSpec)ts).addDrums(this);
 520                         }
 521                         else {
 522                                 ((MelodyTrackSpec)ts).addChords(this);
 523                         }
 524                 }
 525                 return seq;
 526         }
 527 }