apps/plugins/midi/sequencer.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Stepan Moskovchenko
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "plugin.h"
  22 #include "midiutil.h"
  23 #include "guspat.h"
  24 #include "synth.h"
  25
  26 long tempo = 375000;
  27
  28 /* From the old patch config.... each patch is scaled.
  29  * Should be moved into patchset.cfg
  30  * But everyone would need a new config file.
  31  *
  32  * While this really does need to go into the patch config,
  33  * I doubt anyone has made their own custom rockbox patchset
  34  * (if you have, please send a copy my way :) )
  35  */
  36 static const unsigned char patchScale[]=
  37 {
  38     125,115,115,100,100,80,115,100,100,100,100,80,100,100,100,100,
  39     100,100,100,100,60,100,100,100,150,155,145,100,125,86,125,85,
  40     161,160,133,160,135,133,100,128,150,100,100,150,100,130,100,200,
  41     100,100,125,125,100,100,100,100,124,110,111,100,139,113,115,115,
  42     125,115,95,140,100,100,105,100,90,100,80,80,100,125,100,80,
  43     100,100,100,250,130,100,100,100,115,100,100,120,200,100,100,80,
  44     130,100,100,150,100,100,100,100,100,100,200,100,100,100,100,100,
  45     100,100,113,100,200,100,100,100,30,100,100,100,100,100,100,100
  46 };
  47
  48 /* Sets the volume scaling by channel volume and note volume */
  49 /* This way we can do the multiplication/indexing once per   */
  50 /* MIDI event at the most, instead of once per sample.       */
  51 static inline void setVolScale(int a)
  52 {
  53     struct SynthObject * so = &voices[a];
  54     int ch = so->ch;
  55
  56     so->volscale = so->vol * chVol[ch]*patchScale[chPat[ch]] / 100;
  57     //((signed short int)so->vol*(signed short int)chVol[ch])*patchScale[chPat[ch]];
  58 }
  59
  60 static inline void setVol(int ch, int vol)
  61 {
  62     int a;
  63     chVol[ch] = vol;
  64
  65     /* If channel volume changes, we need to recalculate the volume scale */
  66     /* factor for all voices active on this channel                       */
  67     for (a = 0; a < MAX_VOICES; a++)
  68         if (voices[a].ch == ch)
  69             setVolScale(a);
  70 }
  71
  72 static inline void setPatch(int ch, int pat)
  73 {
  74     chPat[ch]=pat;
  75 }
  76
  77 /*
  78     This is the new pitch bend table. There are 512 entries.
  79     The middle entry is exactly 65536 - no bending.
  80
  81     The range of the table is one semitone /in either direction/
  82     Ie, one semitone from the center.
  83
  84     Bends beyond this can be achieved by first offsetting the index
  85     into the GUS frequency table by the appropriate number of semitones,
  86     and then using this table to bend the rest of the way.
  87
  88     Generated using Matlab code:
  89     for i=0:512, fprintf('%d,', round(2^16*2^((i-256)/1536))); end
  90 */
  91
  92 const uint32_t pitchTbl[] ICONST_ATTR={
  93     61858,61872,61886,61900,61914,61928,61942,61956,61970,61983,61997,62011,
  94     62025,62039,62053,62067,62081,62095,62109,62124,62138,62152,62166,62180,
  95     62194,62208,62222,62236,62250,62264,62278,62292,62306,62320,62334,62348,
  96     62362,62376,62390,62404,62419,62433,62447,62461,62475,62489,62503,62517,
  97     62531,62545,62560,62574,62588,62602,62616,62630,62644,62658,62673,62687,
  98     62701,62715,62729,62743,62757,62772,62786,62800,62814,62828,62843,62857,
  99     62871,62885,62899,62913,62928,62942,62956,62970,62984,62999,63013,63027,
 100     63041,63056,63070,63084,63098,63112,63127,63141,63155,63169,63184,63198,
 101     63212,63227,63241,63255,63269,63284,63298,63312,63326,63341,63355,63369,
 102     63384,63398,63412,63427,63441,63455,63470,63484,63498,63512,63527,63541,
 103     63555,63570,63584,63599,63613,63627,63642,63656,63670,63685,63699,63713,
 104     63728,63742,63757,63771,63785,63800,63814,63829,63843,63857,63872,63886,
 105     63901,63915,63929,63944,63958,63973,63987,64002,64016,64030,64045,64059,
 106     64074,64088,64103,64117,64132,64146,64161,64175,64190,64204,64219,64233,
 107     64248,64262,64277,64291,64306,64320,64335,64349,64364,64378,64393,64407,
 108     64422,64436,64451,64465,64480,64494,64509,64524,64538,64553,64567,64582,
 109     64596,64611,64626,64640,64655,64669,64684,64699,64713,64728,64742,64757,
 110     64772,64786,64801,64815,64830,64845,64859,64874,64889,64903,64918,64933,
 111     64947,64962,64976,64991,65006,65020,65035,65050,65065,65079,65094,65109,
 112     65123,65138,65153,65167,65182,65197,65211,65226,65241,65256,65270,65285,
 113     65300,65315,65329,65344,65359,65374,65388,65403,65418,65433,65447,65462,
 114     65477,65492,65506,65521,65536,65551,65566,65580,65595,65610,65625,65640,
 115     65654,65669,65684,65699,65714,65729,65743,65758,65773,65788,65803,65818,
 116     65832,65847,65862,65877,65892,65907,65922,65936,65951,65966,65981,65996,
 117     66011,66026,66041,66056,66071,66085,66100,66115,66130,66145,66160,66175,
 118     66190,66205,66220,66235,66250,66265,66280,66294,66309,66324,66339,66354,
 119     66369,66384,66399,66414,66429,66444,66459,66474,66489,66504,66519,66534,
 120     66549,66564,66579,66594,66609,66624,66639,66654,66670,66685,66700,66715,
 121     66730,66745,66760,66775,66790,66805,66820,66835,66850,66865,66880,66896,
 122     66911,66926,66941,66956,66971,66986,67001,67016,67032,67047,67062,67077,
 123     67092,67107,67122,67137,67153,67168,67183,67198,67213,67228,67244,67259,
 124     67274,67289,67304,67320,67335,67350,67365,67380,67395,67411,67426,67441,
 125     67456,67472,67487,67502,67517,67532,67548,67563,67578,67593,67609,67624,
 126     67639,67655,67670,67685,67700,67716,67731,67746,67761,67777,67792,67807,
 127     67823,67838,67853,67869,67884,67899,67915,67930,67945,67961,67976,67991,
 128     68007,68022,68037,68053,68068,68083,68099,68114,68129,68145,68160,68176,
 129     68191,68206,68222,68237,68252,68268,68283,68299,68314,68330,68345,68360,
 130     68376,68391,68407,68422,68438,68453,68468,68484,68499,68515,68530,68546,
 131     68561,68577,68592,68608,68623,68639,68654,68670,68685,68701,68716,68732,
 132     68747,68763,68778,68794,68809,68825,68840,68856,68871,68887,68902,68918,
 133     68933,68949,68965,68980,68996,69011,69027,69042,69058,69074,69089,69105,
 134     69120,69136,69152,69167,69183,69198,69214,69230,69245,69261,69276,69292,
 135     69308,69323,69339,69355,69370,69386,69402,69417,69433
 136 };
 137
 138
 139 static void findDelta(struct SynthObject * so, int ch, int note)
 140 {
 141     struct GWaveform * wf =
 142         patchSet[chPat[ch]]->waveforms[patchSet[chPat[ch]]->noteTable[note]];
 143     so->wf = wf;
 144
 145     /* Used to be unsigned int, but math had to be done in different order to avoid overflow */
 146     unsigned long long delta = 0;
 147
 148 /*
 149     Old formula:
 150     delta = (((gustable[note+chPBNoteOffset[ch]]<<FRACTSIZE) / (wf->rootFreq)) * wf->sampRate / (SAMPLE_RATE));
 151
 152     Plus some pitch stuff. See old SVN for how it used to be
 153 */
 154
 155     delta = (((gustable[note+chPBNoteOffset[ch]]))); /* anywhere from 8000 to 8000000 */
 156     delta = delta * wf->sampRate;           /* approx 20000 - 44000 but can vary with tuning */
 157     delta = (delta * chPBFractBend[ch]);    /* approx 60000 - 70000 */
 158     delta = delta / (SAMPLE_RATE);  /* 44100 or 22050 */
 159     delta = delta / (wf->rootFreq); /* anywhere from 8000 to 8000000 */
 160
 161     /* Pitch bend is encoded as a fractional of 16 bits, hence the 16 */
 162     delta = delta >> (16 - FRACTSIZE);  /* a shift of approx 4 bits */
 163     so->delta = delta;
 164 }
 165
 166 static inline void computeDeltas(int ch)
 167 {
 168     int a;
 169     for (a = 0; a < MAX_VOICES; a++)
 170     {
 171         if (voices[a].isUsed && voices[a].ch == ch)
 172         {
 173             findDelta(&voices[a], ch, voices[a].note);
 174         }
 175     }
 176 }
 177
 178 static inline void setPW(int ch, int msb, int lsb)
 179 {
 180     chPW[ch] = msb<<2|lsb>>5;
 181
 182     int totalBend = (chPW[ch]-256) * chPBDepth[ch];
 183     chPBNoteOffset[ch] = totalBend >> 8;
 184     chPBFractBend[ch] = pitchTbl[(totalBend & 0xFF) + 256];
 185
 186     computeDeltas(ch);
 187 }
 188
 189 inline void pressNote(int ch, int note, int vol)
 190 {
 191     static int lastKill = 0;
 192 /* Silences all channels but one, for easy debugging, for me. */
 193 /*
 194     if(ch == 0) return;
 195     if(ch == 1) return;
 196     if(ch == 2) return;
 197     if(ch == 3) return;
 198     if(ch == 4) return;
 199     if(ch == 5) return;
 200     if(ch == 6) return;
 201     if(ch == 7) return;
 202     if(ch == 8) return;
 203     if(ch == 9) return;
 204     if(ch == 10) return;
 205     if(ch == 11) return;
 206     if(ch == 12) return;
 207     if(ch == 13) return;
 208     if(ch == 14) return;
 209     if(ch == 15) return;
 210 */
 211     int a;
 212     for (a = 0; a < MAX_VOICES; a++)
 213     {
 214         if (voices[a].ch == ch && voices[a].note == note)
 215             break;
 216
 217         if (!voices[a].isUsed)
 218             break;
 219     }
 220     if (a == MAX_VOICES)
 221     {
 222 //        printf("\nVoice kill");
 223 //        printf("\nToo many voices playing at once. No more left");
 224 //        printf("\nVOICE DUMP: ");
 225 //        for(a=0; a<48; a++)
 226 //            printf("\n#%d  Ch=%d  Note=%d  curRate=%d   curOffset=%d   curPoint=%d   targetOffset=%d", a, voices[a].ch, voices[a].note, voices[a].curRate, voices[a].curOffset, voices[a].curPoint, voices[a].targetOffset);
 227         lastKill++;
 228         if (lastKill == MAX_VOICES)
 229             lastKill = 0;
 230         a = lastKill;
 231 //        return; /* None available */
 232     }
 233     voices[a].ch = ch;
 234     voices[a].note = note;
 235     voices[a].vol = vol;
 236     voices[a].cp = 0;
 237     voices[a].state = STATE_ATTACK;
 238     voices[a].decay = 255;
 239
 240     setVolScale(a);
 241
 242     voices[a].loopState=STATE_NONLOOPING;
 243     /*
 244      * OKAY. Gt = Gus Table value
 245      * rf = Root Frequency of wave
 246      * SR = sound sampling rate
 247      * sr = WAVE sampling rate
 248      */
 249
 250     if (ch != 9)
 251     {
 252         findDelta(&voices[a], ch, note);
 253         /* Turn it on */
 254         voices[a].isUsed = true;
 255         setPoint(&voices[a], 0);
 256     } else
 257     {
 258         if (drumSet[note] != NULL)
 259         {
 260             if (note < 35)
 261                 printf("NOTE LESS THAN 35, AND A DRUM PATCH EXISTS FOR THIS? WHAT THE HELL?");
 262
 263             struct GWaveform * wf = drumSet[note]->waveforms[0];
 264             voices[a].wf = wf;
 265             voices[a].delta = (((gustable[note]<<FRACTSIZE) / wf->rootFreq) * wf->sampRate / SAMPLE_RATE);
 266             if (wf->mode & 28)
 267 //                printf("\nWoah, a drum patch has a loop. Stripping the loop...");
 268             wf->mode = wf->mode & (255-28);
 269
 270             /* Turn it on */
 271             voices[a].isUsed = true;
 272             setPoint(&voices[a], 0);
 273
 274         } else
 275         {
 276 /*            printf("\nWarning: drum %d does not have a patch defined... Ignoring it", note); */
 277         }
 278     }
 279 }
 280
 281 static void releaseNote(int ch, int note)
 282 {
 283     if (ch == 9)
 284         return;
 285
 286     int a;
 287     for (a = 0; a < MAX_VOICES; a++)
 288     {
 289         if (voices[a].ch == ch && voices[a].note == note)
 290         {
 291             if (voices[a].wf->mode & 28)
 292             {
 293                 setPoint(&voices[a], 3);
 294             }
 295         }
 296     }
 297 }
 298
 299 static void sendEvent(struct Event * ev)
 300 {
 301     const unsigned char status_low = ev->status & 0x0F;
 302     const unsigned char d1 = ev->d1;
 303     const unsigned char d2 = ev->d2;
 304     switch (ev->status & 0xF0)
 305     {
 306         case MIDI_CONTROL:
 307             switch (d1)
 308             {
 309                 case CTRL_VOLUME:
 310                 {
 311                     setVol((status_low), d2);
 312                     return;
 313                 }
 314                 case CTRL_PANNING:
 315                 {
 316                     chPan[status_low] = d2;
 317                     return;
 318                 }
 319                 case CTRL_DATAENT_MSB:
 320                 {
 321                     /* TODO: Update all deltas. Is this really needed? */
 322                     if(chLastCtrlMSB[status_low] == REG_PITCHBEND_MSB &&
 323                        chLastCtrlLSB[status_low] == REG_PITCHBEND_LSB)
 324                     {
 325 //                         printf("Pitch bend depth set to %d\n", d2);
 326                         chPBDepth[status_low] = d2;
 327                     }
 328                     return;
 329                 }
 330
 331                 case CTRL_NONREG_LSB:
 332                 {
 333                     chLastCtrlLSB[status_low] = 0xFF;   /* Ignore nonregistered writes */
 334                     return;
 335                 }
 336
 337                 case CTRL_NONREG_MSB:
 338                 {
 339                     chLastCtrlMSB[status_low] = 0xFF;   /* Ignore nonregistered writes */
 340                     return;
 341                 }
 342
 343                 case CTRL_REG_LSB:
 344                 {
 345                     chLastCtrlLSB[status_low] = d2;
 346                     return;
 347                 }
 348
 349                 case CTRL_REG_MSB:
 350                 {
 351                     chLastCtrlMSB[status_low] = d2;
 352                     return;
 353                 }
 354
 355             }
 356             break;
 357
 358         case MIDI_PITCHW:
 359             setPW((status_low), d2, d1);
 360             return;
 361
 362         case MIDI_NOTE_ON:
 363             switch (d2)
 364             {
 365                 case 0: /* Release by vol=0 */
 366                     releaseNote(status_low, d1);
 367                     return;
 368
 369                 default:
 370                     pressNote(status_low, d1, d2);
 371                     return;
 372             }
 373
 374         case MIDI_NOTE_OFF:
 375             releaseNote(status_low, d1);
 376             return;
 377
 378         case MIDI_PRGM:
 379             if (status_low != 9)
 380                 setPatch(status_low, d1);
 381     }
 382 }
 383
 384 void rewindFile(void)
 385 {
 386     int i;
 387     for (i = 0; i < mf->numTracks; i++)
 388     {
 389         mf->tracks[i]->delta = 0;
 390         mf->tracks[i]->pos = 0;
 391     }
 392 }
 393
 394 int tick(void) ICODE_ATTR;
 395 int tick(void)
 396 {
 397     if (mf == NULL)
 398         return 0;
 399
 400     int a, tracksAdv=0;
 401     for (a = 0; a < mf->numTracks; a++)
 402     {
 403         struct Track * tr = mf->tracks[a];
 404
 405         if (tr == NULL)
 406             printf("NULL TRACK: %d", a);
 407
 408         //BIG DEBUG STATEMENT
 409         //printf("\nTrack %2d,  Event = %4d of %4d,   Delta = %5d,    Next = %4d", a, tr->pos, tr->numEvents, tr->delta, getEvent(tr, tr->pos)->delta);
 410
 411         if (tr != NULL && (tr->pos < tr->numEvents))
 412         {
 413             tr->delta++;
 414             tracksAdv++;
 415             while (getEvent(tr, tr->pos)->delta <= tr->delta)
 416             {
 417                 struct Event * e = getEvent(tr, tr->pos);
 418
 419                 if (e->status != 0xFF)
 420                 {
 421                     sendEvent(e);
 422                     if ((e->status&0xF0) == MIDI_PRGM)
 423                     {
 424 /*                        printf("\nPatch Event, patch[%d] ==> %d", e->status&0xF, e->d1); */
 425                     }
 426                 }
 427                 else
 428                 {
 429                     if (e->d1 == 0x51)
 430                     {
 431                         tempo = (((short)e->evData[0])<<16)|(((short)e->evData[1])<<8)|(e->evData[2]);
 432 /*                        printf("\nMeta-Event: Tempo Set = %d", tempo); */
 433                         bpm=mf->div*1000000/tempo;
 434                         number_of_samples=SAMPLE_RATE/bpm;
 435
 436                     }
 437                 }
 438                 tr->delta = 0;
 439                 tr->pos++;
 440                 if (tr->pos >= (tr->numEvents-1))
 441                     break;
 442             }
 443         }
 444     }
 445
 446     samples_this_second += number_of_samples;
 447
 448     while (samples_this_second >= SAMPLE_RATE)
 449     {
 450         samples_this_second -= SAMPLE_RATE;
 451         playing_time++;
 452     }
 453
 454     if (tracksAdv != 0)
 455         return 1;
 456     else
 457         return 0;
 458 }
 459
 460 void seekBackward(int nsec)
 461 {
 462     int notes_used, a;
 463     int desired_time = playing_time - nsec;  /* Rewind 5 sec */
 464
 465     if (desired_time < 0)
 466         desired_time = 0;
 467
 468     /* Set controllers to default values */
 469     resetControllers();
 470
 471     /* Set the tempo to defalt */
 472     bpm = mf->div*1000000/tempo;
 473     number_of_samples = SAMPLE_RATE/bpm;
 474
 475     /* Reset the tracks to start */
 476     rewindFile();
 477
 478     /* Reset the time counter to 0 */
 479     playing_time = 0;
 480     samples_this_second = 0;
 481
 482     /* Quickly run through any initial things that occur before notes */
 483     do
 484     {
 485         notes_used = 0;
 486         for (a = 0; a < MAX_VOICES; a++)
 487             if (voices[a].isUsed)
 488                 notes_used++;
 489         tick();
 490     } while (notes_used == 0);
 491
 492     /* Reset the time counter to 0 */
 493     playing_time = 0;
 494     samples_this_second = 0;
 495
 496     /* Tick until goal is reached */
 497     while (playing_time < desired_time)
 498         tick();
 499 }
 500
 501 void seekForward(int nsec)
 502 {
 503     int desired_time = playing_time + nsec;
 504     while (tick() && playing_time < desired_time);
 505 }
 506