sequencer/src/pattern.C

   1
   2 /*******************************************************************************/
   3 /* Copyright (C) 2007-2008 Jonathan Moore Liles                                */
   4 /*                                                                             */
   5 /* This program is free software; you can redistribute it and/or modify it     */
   6 /* under the terms of the GNU General Public License as published by the       */
   7 /* Free Software Foundation; either version 2 of the License, or (at your      */
   8 /* option) any later version.                                                  */
   9 /*                                                                             */
  10 /* This program is distributed in the hope that it will be useful, but WITHOUT */
  11 /* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       */
  12 /* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for   */
  13 /* more details.                                                               */
  14 /*                                                                             */
  15 /* You should have received a copy of the GNU General Public License along     */
  16 /* with This program; see the file COPYING.  If not,write to the Free Software */
  17 /* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18 /*******************************************************************************/
  19
  20 #include "pattern.H"
  21 #include "non.H"
  22 #include "common.h"
  23 #include "smf.H"
  24
  25 #include "jack.H"
  26 #include "transport.H"
  27 #include <math.h>
  28
  29 int pattern::note_shape = SQUARE;
  30
  31 event_list pattern::_recorded_events;
  32 vector <pattern*> pattern::_patterns;
  33 int pattern::_solo;
  34 int pattern::_pattern_recording;
  35
  36 signal <void> pattern::signal_create_destroy;
  37
  38 pattern::pattern ( void )
  39 {
  40     viewport.h = 32;
  41     viewport.w = 32;
  42
  43     viewport.y = 64 - ( viewport.h + ( viewport.h / 2 ) );
  44
  45     _channel = _port = 0;
  46
  47     _ppqn = 4;
  48     _bpb  = 4;
  49     _note = 8;
  50
  51     _queued = -1;
  52
  53     int _bars = 2;
  54
  55     // we need to reinitalize this.
  56     data *d = const_cast< data * >( _rd );
  57
  58     d->length = x_to_ts( _bpb * _ppqn * _bars );
  59
  60 //    mapping.open( Mapping::INSTRUMENT, "Default" );
  61     mapping.open( Mapping::SCALE, "Major" );
  62
  63     _add();
  64
  65     char *s;
  66     asprintf( &s, "Pattern %d", number() );
  67
  68     name( s );
  69 }
  70
  71 void
  72 pattern::_add ( void )
  73 {
  74     // keep track of all the patterns
  75     pattern::_patterns.push_back( this );
  76     _number = patterns();
  77
  78     signal_create_destroy();
  79 }
  80
  81 pattern::~pattern ( void )
  82 {
  83     DMESSAGE( "deleting pattern %d", number() );
  84     signal_create_destroy();
  85 }
  86
  87 /* copy constructor */
  88 pattern::pattern ( const pattern &rhs ) : Grid( rhs )
  89 {
  90     _note    = rhs._note;
  91     _port    = rhs._port;
  92     _channel = rhs._channel;
  93     _queued  = rhs._queued;
  94
  95     mapping = rhs.mapping;
  96
  97     _add();
  98 }
  99
 100 pattern *
 101 pattern::clone ( void )
 102 {
 103     return new pattern( *this );
 104 }
 105
 106 /******************/
 107 /* Static methods */
 108 /******************/
 109
 110 int
 111 pattern::solo ( void )
 112 {
 113     return pattern::_solo;
 114 }
 115
 116 int
 117 pattern::patterns ( void )
 118 {
 119     return pattern::_patterns.size();
 120 }
 121
 122 // this is the static one
 123 pattern *
 124 pattern::pattern_by_number ( int n )
 125 {
 126     if ( n <= patterns() && n > 0 )
 127     {
 128         return pattern::_patterns[ n - 1 ];
 129     }
 130     return NULL;
 131 }
 132
 133 /** delete all patterns in preparation for a reload */
 134 void
 135 pattern::reset ( void )
 136 {
 137     for ( int n = pattern::patterns(); n-- ; )
 138     {
 139         delete pattern::_patterns.back();
 140         pattern::_patterns.pop_back();
 141     }
 142 }
 143
 144 /* records a MIDI event into a temporary buffer. It'll only be
 145  * permanently added to pattern after recording stops or the pattern
 146  * loops. */
 147 void
 148 pattern::record_event ( const midievent *me )
 149 {
 150     /* set the events aside in a dedicated list--the recording pattern
 151      * will decide what to do with them the next time around the
 152      * loop */
 153
 154     /* FIXME: how does the pattern decide when to loop? It seems
 155        reasonable that /merge/ and /replace/ modes should be bound to
 156        the previous pattern length, but what about "NEW" mode? Should it
 157        just use this entire list as a new pattern (of whatever length)
 158        when recording is halted? */
 159
 160     event *e = new event;
 161
 162     *e = *me;
 163
 164     pattern::_recorded_events.append( e );
 165
 166     record_mode_e mode = config.record_mode;
 167
 168     if ( mode == OVERWRITE || mode == LAYER )
 169     {
 170         pattern *p = pattern::recording();
 171
 172         if ( ! p->_cleared )
 173         {
 174
 175             if ( mode == LAYER )
 176             {
 177                 p->record_stop();
 178
 179                 p = p->clone();
 180
 181                 p->record( 0 );
 182             }
 183
 184             p->clear();
 185
 186             p->_cleared = true;
 187         }
 188
 189         mode = MERGE;
 190     }
 191
 192     /* let's fill in the pattern 'live' in merge mode. looks a little
 193        complicated because we have to wait for a note-off before it's
 194        safe to insert */
 195     if ( mode == MERGE || mode == NEW )
 196     {
 197
 198         pattern *p = pattern::recording();
 199
 200         p->lock();
 201
 202         event_list *el = &pattern::_recorded_events;
 203
 204         if ( e->is_note_off() )
 205         {
 206             event *off = e;
 207
 208             for ( event *on = el->last(); on; on = on->prev() )
 209             {
 210                 if ( on->is_note_on() &&
 211                      on->is_same_note( off ) )
 212                     // &&
 213                     //   *on < *e )
 214                 {
 215                     el->unlink( on );
 216                     el->unlink( off );
 217
 218                     tick_t duration = off->timestamp() - on->timestamp();
 219
 220                     /* place within loop */
 221                     on->timestamp(
 222                         fmod( on->timestamp() - p->_start, p->_rw->length ) );
 223
 224                     on->link( off );
 225                     on->note_duration( duration );
 226
 227                     p->_rw->events.mix( on );
 228
 229                     break;
 230                 }
 231             }
 232         }
 233         else
 234             if ( ! e->is_note_on() )
 235             {
 236
 237                 // if ( ! filter )
 238
 239                 e->timestamp( fmod( e->timestamp(), p->_rw->length ) );
 240
 241                 el->unlink( e );
 242                 p->_rw->events.insert( e );
 243             }
 244
 245         p->_suspend_update = true;
 246         p->unlock();
 247         p->_suspend_update = false;
 248     }
 249 }
 250
 251 pattern *
 252 pattern::recording ( void )
 253 {
 254     return pattern::pattern_by_number( pattern::_pattern_recording );
 255 }
 256
 257 \f
 258
 259 /*******************/
 260 /* Virtual Methods */
 261 /*******************/
 262
 263 /* allows us to create a new pattern/phrase from a base class pointer  */
 264 pattern *
 265 pattern::create ( void )
 266 {
 267     if ( pattern::patterns() < 128 )
 268     {
 269         return new pattern;
 270     }
 271     else
 272         return NULL;
 273 }
 274
 275 pattern *
 276 pattern::by_number ( int n ) const
 277 {
 278     return pattern::pattern_by_number( n );
 279 }
 280
 281 void
 282 pattern::put ( int x, int y, tick_t l )
 283 {
 284     l = l ? l : PPQN * 4 / _note;
 285
 286     Grid::put( x, y, l );
 287
 288     if ( ! transport.rolling )
 289     {
 290         /* echo note */
 291         midievent e;
 292
 293         e.status( event::NOTE_ON );
 294         e.channel( _channel );
 295         e.timestamp( l );
 296         e.note( y_to_note( y ) );
 297         e.note_velocity( 64 );
 298
 299         midi_output_immediate_event ( _port, &e );
 300     }
 301 }
 302
 303 const char *
 304 pattern::row_name ( int r ) const
 305 {
 306     return mapping.note_name( y_to_note( r ) );
 307 }
 308
 309 void
 310 pattern::draw_row_names ( Canvas *c ) const
 311 {
 312     for ( int y = 128; y-- ; )
 313         c->draw_row_name( y, mapping.note_name( y_to_note( y ) ), mapping.velocity( y_to_note( y ) ) );
 314 }
 315
 316 void
 317 pattern::trigger ( tick_t start, tick_t end )
 318 {
 319     /* ASSERT( end != -1 && start <= end, "programming error: invalid loop trigger! (%lu-%lu)", start, end ); */
 320
 321     _start = start;
 322     _end   = end;
 323 }
 324
 325 /* trigger forever */
 326 void
 327 pattern::trigger ( void )
 328 {
 329     trigger( transport.frame / transport.frames_per_tick, INFINITY );
 330 }
 331
 332 void
 333 pattern::stop ( void ) const
 334 {
 335     _playing = false;
 336
 337     _start = 0;
 338     _end   = 0;
 339     _index = 0;
 340 }
 341
 342
 343 void
 344 pattern::mode ( int n )
 345 {
 346     if ( QUEUE == song.play_mode )
 347     {
 348         queue( n );
 349         return;
 350     }
 351
 352     if ( n == SOLO )
 353     {
 354         if ( pattern::_solo )
 355             ((Grid*)pattern::pattern_by_number( pattern::_solo ))->mode( PLAY );
 356         pattern::_solo = _number;
 357         Grid::mode( SOLO );
 358     }
 359     else
 360     {
 361         if ( pattern::_solo == _number )
 362             pattern::_solo = 0;
 363
 364         Grid::mode( n );
 365     }
 366 }
 367
 368 int
 369 pattern::mode ( void ) const
 370 {
 371     if ( pattern::_solo )
 372     {
 373         if ( pattern::_solo == _number )
 374             return SOLO;
 375         else
 376             return MUTE;
 377     }
 378     else
 379         return Grid::mode();
 380 }
 381
 382 /* queue a mode change for the next loop  */
 383 void
 384 pattern::queue ( int m )
 385 {
 386     _queued = m;
 387 }
 388
 389 int
 390 pattern::queue ( void ) const
 391 {
 392     return _queued;
 393 }
 394
 395 /* WARNING: runs in the RT thread! */
 396 // output notes from /start/ to /end/ (absolute)
 397 void
 398 pattern::play ( tick_t start, tick_t end ) const
 399 {
 400     /* get our own copy of this pointer so UI thread can change it. */
 401     const data *d = const_cast< const data * >(_rd);
 402
 403     if ( start > _end )
 404     {
 405         stop();
 406 //        WARNING( "attempt to play a loop (pattern %d) that has ended (%lu, %lu)", number(), start, _end );
 407         return;
 408     }
 409     else
 410         if ( end < _start )
 411             // not ready yet
 412             return;
 413
 414     if ( start < _start )
 415         start = _start;
 416
 417     if ( end > _end )
 418         end = _end;
 419
 420     // where we are in the absolute time
 421     tick_t tick = start - _start;
 422     int num_played = tick / d->length;
 423     tick_t offset = _start + (d->length * num_played);
 424
 425     const event *e;
 426
 427     _index = fmod( tick, d->length );
 428
 429     bool reset_queued = false;
 430
 431     if ( _index < end - start )
 432     {
 433         /* period covers the beginning of the loop  */
 434         DMESSAGE( "%s pattern %d at tick %f (ls: %f, le: %f, o: %f)", _playing ? "Looped" : "Triggered", number(), start, _start, _end, offset  );
 435
 436         _cleared = false;
 437
 438         if ( PLAY == _queued || SOLO == _queued )
 439         {
 440             /* set the start point to loop boundary */
 441             start = start - _index;
 442             _mode = _queued;
 443
 444             if ( SOLO == _mode )
 445             {
 446                 if ( pattern::_solo )
 447                     ((Grid*)pattern::pattern_by_number( pattern::_solo ))->mode( PLAY );
 448
 449                  pattern::_solo = _number;
 450             }
 451             else
 452             {
 453                 if ( pattern::_solo == _number )
 454                     pattern::_solo = 0;
 455             }
 456
 457             reset_queued = true;
 458         }
 459     }
 460     else if ( _index >= d->length - ( end - start ) )
 461     {
 462         if ( MUTE == _queued )
 463         {
 464             /* set the end point to loop boundary */
 465             end = end - _index;
 466
 467             reset_queued = true;
 468         }
 469     }
 470
 471     _playing = true;
 472
 473     if ( mode() == MUTE )
 474         goto done;
 475
 476 try_again:
 477
 478     // pattern is empty
 479     if ( d->events.empty() )
 480         goto done;
 481
 482     for ( e = d->events.first(); e; e = e->next() )
 483     {
 484         //    MESSAGE( "s[%ld] -> t[%ld] : %ld, len %ld", start, end, e->timestamp(), _length ); // (*e).print();
 485
 486         tick_t ts = e->timestamp() + offset;
 487
 488         if ( ts >= end )
 489             goto done;
 490
 491         if ( ts >= start )
 492         {
 493             midievent me = *e;
 494
 495
 496             //           MESSAGE( "timestamp %d, tick %d, ts - start == %lu", e->timestamp(), start,
 497             //                    e->timestamp() - start);
 498
 499             /* set the channel */
 500             me.channel( _channel );
 501
 502             /* set the in-cycle timestamp */
 503             me.timestamp ( ts - start );
 504
 505             if ( me.is_note_on() )
 506             {
 507                 if ( mapping.translate( &me ) )
 508                     midi_output_event( _port, &me, 1 + e->note_duration() );
 509             }
 510             else
 511                 if ( me.is_note_off() )
 512                 {
 513                     if ( mapping.translate( &me ) )
 514                         midi_output_event( _port, &me, 0 );
 515                 }
 516                 else
 517                     /* any other event type */
 518                     midi_output_event( _port, &me );
 519         }
 520     }
 521
 522     // ran out of events, but there's still some loop left to play.
 523     offset += d->length;
 524     goto try_again;
 525
 526     DMESSAGE( "out of events, resetting to satisfy loop" );
 527
 528 done:
 529
 530     if ( _queued >= 0 && reset_queued )
 531     {
 532         _mode = _queued;
 533         _queued = -1;
 534     }
 535
 536     if ( _end == end )
 537     {
 538         /* we're done playing this trigger */
 539         DMESSAGE( "Pattern %d ended at tick %f (ls: %f, le: %f, o: %f)", number(), end, _start, _end, offset  );
 540
 541         stop();
 542     }
 543
 544 }
 545
 546 /* Import /track/ of /f/ as new pattern */
 547 pattern *
 548 pattern::import ( smf *f, int track )
 549 {
 550     if ( ! f->seek_track( track ) )
 551         return NULL;
 552
 553     pattern *p = new pattern;
 554
 555     p->lock();
 556
 557     p->load( f );
 558
 559     /* file could have any notes in it... Use Chromatic scale to
 560        ensure all are visible  */
 561     p->mapping.open( Mapping::SCALE, "Chromatic" );
 562
 563     p->unlock();
 564
 565     p->fit();
 566
 567     return p;
 568 }
 569
 570 /** fill pattern from current track of /f/ */
 571 void
 572 pattern::load ( smf *f )
 573 {
 574     lock();
 575
 576     f->read_pattern_info( this );
 577
 578     tick_t len;
 579
 580     list <midievent> *e = f->read_track_events( &len );
 581
 582     /* set channel to channel of first event... */
 583     if ( e->size() )
 584         _channel = e->front().channel();
 585
 586     /* copy events into pattern */
 587     _rw->events = *e;
 588     delete e;
 589
 590     if ( len )
 591         _rw->length = len;
 592
 593     unlock();
 594
 595 //    print();
 596 }
 597
 598 /** save (export) pattern to file /name/  */
 599 void
 600 pattern::save ( const char *name ) const
 601 {
 602     smf f;
 603
 604     /* open for writing */
 605     f.open( name, smf::WRITE );
 606
 607     /* writing SMF 0 track */
 608     f.write_header( 0 );
 609
 610     f.open_track( _name, _number );
 611
 612     Grid::dump( &f, _channel );
 613
 614     f.close_track( length() );
 615 }
 616
 617 /** dump pattern as a track in an already open MIDI file */
 618 void
 619 pattern::dump ( smf *f ) const
 620 {
 621     f->open_track( _name, _number );
 622
 623     f->write_pattern_info( this );
 624
 625     Grid::dump( f, _channel  );
 626
 627     f->close_track( length() );
 628 }
 629
 630
 631 void
 632 pattern::randomize_row ( int y, int feel, float probability )
 633 {
 634     lock();
 635
 636     int l = PPQN * 4 / _note;
 637
 638     int bx = ts_to_x( _rw->length - l );
 639
 640     float *p = (float *)alloca( feel * sizeof( float ) );
 641
 642     float prob = probability;
 643     for ( int i = 0; i < feel; i++ )
 644     {
 645         p[i] = prob;
 646         // reduce probability as we move away from center
 647         prob *= 0.5;
 648     }
 649
 650     for ( int x = 0; x < bx; x++ )
 651     {
 652         float r = ((float)rand()) / RAND_MAX;
 653
 654         if ( p[ x % feel ] + r >= 1 )
 655             put( x, y, l );
 656     }
 657
 658     unlock();
 659 }
 660
 661 /*************/
 662 /* Recording */
 663 /*************/
 664
 665 void
 666 pattern::record ( int mode )
 667 {
 668     _recording = true;
 669     pattern::_pattern_recording = _number;
 670 }
 671
 672 void
 673 pattern::record_stop ( void )
 674 {
 675     if ( ! _recording )
 676         return;
 677
 678     _recording = false;
 679
 680     if ( config.record_mode == NEW )
 681         trim();
 682
 683     pattern::_recorded_events.clear();
 684 }
 685
 686 \f
 687
 688 /*******************************/
 689 /* Pattern specific accessors. */
 690 /*******************************/
 691
 692
 693 int
 694 pattern::port ( void ) const
 695 {
 696     return _port;
 697 }
 698
 699 void
 700 pattern::port ( int p )
 701 {
 702     _port = p;
 703 }
 704
 705 int
 706 pattern::channel ( void ) const
 707 {
 708     return _channel;
 709 }
 710
 711 void
 712 pattern::channel ( int c )
 713 {
 714     _channel = c;
 715 }
 716
 717 int
 718 pattern::note ( void ) const
 719 {
 720     return _note;
 721 }
 722
 723 void
 724 pattern::note ( int n )
 725 {
 726     _note = n;
 727 }
 728
 729
 730 int
 731 pattern::ppqn ( void ) const
 732 {
 733     return _ppqn;
 734 }
 735
 736 void
 737 pattern::ppqn ( int n )
 738 {
 739     _ppqn = n;
 740 }
 741
 742 int
 743 pattern::key ( void ) const
 744 {
 745     return mapping.key();
 746 }
 747
 748 void
 749 pattern::key ( int k )
 750 {
 751     mapping.key( k );
 752 }