rockbox/apps/plugins/midi/synth.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 *
 * Copyright (C) 2005 Stepan Moskovchenko
 *
 * All files in this archive are subject to the GNU General Public License.
 * See the file COPYING in the source tree root for full license agreement.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/

extern struct plugin_api * rb;

struct Event * getEvent(struct Track * tr, int evNum)
{
    return tr->dataBlock + (evNum*sizeof(struct Event));
}

void readTextBlock(int file, char * buf)
{
    char c = 0;
    do
    {
        c = readChar(file);
    } while(c == '\n' || c == ' ' || c=='\t');

    rb->lseek(file, -1, SEEK_CUR);
    int cp = 0;
    do
    {
        c = readChar(file);
        buf[cp] = c;
        cp++;
    } while (c != '\n' && c != ' ' && c != '\t' && !eof(file));
    buf[cp-1]=0;
    rb->lseek(file, -1, SEEK_CUR);
}



/* Filename is the name of the config file              */
/* The MIDI file should have been loaded at this point  */
int initSynth(struct MIDIfile * mf, char * filename, char * drumConfig)
{
    char patchUsed[128];
    char drumUsed[128];
    int a=0;
    for(a=0; a<MAX_VOICES; a++)
    {
        voices[a].cp=0;
        voices[a].vol=0;
        voices[a].ch=0;
        voices[a].isUsed=0;
        voices[a].note=0;
    }

    for(a=0; a<16; a++)
    {
        chVol[a]=100;            /* Default, not quite full blast.. */
            chPanLeft[a]=64;     /* Center                          */
        chPanRight[a]=64;        /* Center                          */
        chPat[a]=0;              /* Ac Gr Piano                     */
        chPW[a]=64;              /* .. not .. bent ?                */
    }
    for(a=0; a<128; a++)
    {
        patchSet[a]=NULL;
        drumSet[a]=NULL;
        patchUsed[a]=0;
        drumUsed[a]=0;
    }

    /*
     * Always load the piano.
     * Some files will assume its loaded without specifically
     * issuing a Patch command... then we wonder why we can't hear anything
     */
    patchUsed[0]=1;

    /* Scan the file to see what needs to be loaded */
    for(a=0; a<mf->numTracks; a++)
    {
        unsigned int ts=0;

        if(mf->tracks[a] == NULL)
        {
            printf("\nNULL TRACK !!!");
            rb->splash(HZ*2, true, "Null Track in loader.");
            return -1;
        }

        for(ts=0; ts<mf->tracks[a]->numEvents; ts++)
        {

            if((getEvent(mf->tracks[a], ts)->status) == (MIDI_NOTE_ON+9))
                drumUsed[getEvent(mf->tracks[a], ts)->d1]=1;

            if( (getEvent(mf->tracks[a], ts)->status & 0xF0) == MIDI_PRGM)
            {
                if(patchUsed[getEvent(mf->tracks[a], ts)->d1]==0)
                    printf("\nI need to load patch %d.", getEvent(mf->tracks[a], ts)->d1);
                patchUsed[getEvent(mf->tracks[a], ts)->d1]=1;
            }
        }
    }

    int file = rb->open(filename, O_RDONLY);
    if(file == -1)
    {
        rb->splash(HZ*2, true, "Bad patch config.\nDid you install the patchset?");
        return -1;
    }

    char name[40];
    char fn[40];

    /* Scan our config file and load the right patches as needed    */
    int c = 0;
    rb->snprintf(name, 40, "");
    for(a=0; a<128; a++)
    {
        while(readChar(file)!=' ' && !eof(file));
        readTextBlock(file, name);

        rb->snprintf(fn, 40, "/.rockbox/patchset/%s.pat", name);
        printf("\nLOADING: <%s> ", fn);

        if(patchUsed[a]==1)
        {
            patchSet[a]=gusload(fn);

            if(patchSet[a] == NULL) /* There was an error loading it */
                return -1;
        }

        while((c != '\n'))
            c = readChar(file);
    }
    rb->close(file);

    file = rb->open(drumConfig, O_RDONLY);
    if(file == -1)
    {
        rb->splash(HZ*2, true, "Bad drum config.\nDid you install the patchset?");
        return -1;
    }

    /* Scan our config file and load the drum data  */
    int idx=0;
    char number[30];
    while(!eof(file))
    {
        readTextBlock(file, number);
        readTextBlock(file, name);
        rb->snprintf(fn, 40, "/.rockbox/patchset/%s.pat", name);

        idx = rb->atoi(number);
        if(idx == 0)
            break;

        if(drumUsed[idx]==1)
        {
            drumSet[idx]=gusload(fn);

            if(drumSet[idx] == NULL)    /* Error loading patch */
                return -1;
        }

        while((c != '\n') && (c != 255) && (!eof(file)))
            c = readChar(file);
    }
    rb->close(file);
    return 0;
}



int currentVoice IDATA_ATTR;
struct SynthObject * so IDATA_ATTR;
struct GWaveform * wf IDATA_ATTR;
int s IDATA_ATTR;
short s1 IDATA_ATTR;
short s2 IDATA_ATTR;
short sample IDATA_ATTR;    /* For synthSample */
unsigned int cpShifted IDATA_ATTR;

unsigned char b1 IDATA_ATTR;
unsigned char b2 IDATA_ATTR;


inline int getSample(int s)
{
    /* Sign conversion moved to guspat.c */
    /* 8bit conversion NOT YET IMPLEMENTED in guspat.c */
    return ((short *) wf->data)[s];
}




inline void setPoint(struct SynthObject * so, int pt)
{
    if(so->ch==9) /* Drums, no ADSR */
    {
        so->curOffset = 1<<27;
        so->curRate = 1;
        return;
    }

    if(so->wf==NULL)
    {
        printf("\nCrap... null waveform...");
        exit(1);
    }
    if(so->wf->envRate==NULL)
    {
        printf("\nWaveform has no envelope set");
        exit(1);
    }

    so->curPoint = pt;

    int r=0;
    int rate = so->wf->envRate[pt];

    r=3-((rate>>6) & 0x3);      /* Some blatant Timidity code for rate conversion... */
    r*=3;
    r = (rate & 0x3f) << r;

    /*
     * Okay. This is the rate shift. Timidity defaults to 9, and sets
     * it to 10 if you use the fast decay option. Slow decay sounds better
     * on some files, except on some other files... you get chords that aren't
     * done decaying yet.. and they dont harmonize with the next chord and it
     * sounds like utter crap. Yes, even Timitidy does that. So I'm going to
     * default this to 10, and maybe later have an option to set it to 9
     * for longer decays.
     */
    so->curRate = r<<10;

    /*
     * Do this here because the patches assume a 44100 sampling rate
     * We've halved our sampling rate, ergo the ADSR code will be
     * called half the time. Ergo, double the rate to keep stuff
     * sounding right.
     */
    so->curRate = so->curRate << 1;


    so->targetOffset = so->wf->envOffset[pt]<<(20);
    if(pt==0)
        so->curOffset = 0;
}


inline void stopVoice(struct SynthObject * so)
{
    if(so->state == STATE_RAMPDOWN)
        return;
    so->state = STATE_RAMPDOWN;
    so->decay = 255;

}


inline signed short int synthVoice()
{
    so = &voices[currentVoice];
    wf = so->wf;


    if(so->state != STATE_RAMPDOWN)
    {
        so->cp += so->delta;
    }

    cpShifted = so->cp >> 10;

    if( (cpShifted > (wf->numSamples) && (so->state != STATE_RAMPDOWN)))
    {
        stopVoice(so);
    }

        s2 = getSample((cpShifted)+1);

        /* LOOP_REVERSE|LOOP_PINGPONG  = 24  */
    if((wf->mode & (24)) && so->loopState == STATE_LOOPING && (cpShifted <= (wf->startLoop)))
    {
        if(wf->mode & LOOP_REVERSE)
        {
            so->cp = (wf->endLoop)<<10;
            cpShifted = wf->endLoop;
            s2=getSample((cpShifted));
            } else
            {
                so->delta = -so->delta;
            so->loopDir = LOOPDIR_FORWARD;
        }
    }

    if((wf->mode & 28) && (cpShifted >= wf->endLoop))
    {
        so->loopState = STATE_LOOPING;
        if((wf->mode & (24)) == 0)
        {
            so->cp = (wf->startLoop)<<10;
            cpShifted = wf->startLoop;
            s2=getSample((cpShifted));
        } else
        {
            so->delta = -so->delta;
            so->loopDir = LOOPDIR_REVERSE;
        }
    }

    /* Better, working, linear interpolation    */
    s1=getSample((cpShifted));
    s = s1 + ((signed)((s2 - s1) * (so->cp & 1023))>>10);


/* ADSR COMMENT WOULD GO FROM HERE.........*/

    if(so->curRate == 0)
        stopVoice(so);


    if(so->ch != 9) /* Stupid ADSR code... and don't do ADSR for drums */
    {
        if(so->curOffset < so->targetOffset)
        {
            so->curOffset += (so->curRate);
            if(so -> curOffset > so->targetOffset && so->curPoint != 2)
            {
                if(so->curPoint != 5)
                    setPoint(so, so->curPoint+1);
                else
                    stopVoice(so);
            }
        } else
        {
            so->curOffset -= (so->curRate);
            if(so -> curOffset < so->targetOffset && so->curPoint != 2)
            {

                if(so->curPoint != 5)
                    setPoint(so, so->curPoint+1);
                else
                    stopVoice(so);

            }
        }
    }

    if(so->curOffset < 0)
        so->isUsed=0;  /* This is OK because offset faded it out already */


    s = (s * (so->curOffset >> 22) >> 8);

/* ............. TO HERE */


    if(so->state == STATE_RAMPDOWN)
    {
        so->decay--;
        if(so->decay == 0)
            so->isUsed=0;
        s = (s * so->decay) >> 8;
    }

    return s*((signed short int)so->vol*(signed short int)chVol[so->ch])>>14;
}


inline void synthSample(int * mixL, int * mixR)
{
    *mixL = 0;
    *mixR = 0;
    for(currentVoice=0; currentVoice<MAX_VOICES; currentVoice++)
    {
        if(voices[currentVoice].isUsed==1)
        {
            sample = synthVoice(currentVoice);
            *mixL += (sample*chPanLeft[voices[currentVoice].ch])>>7;
            *mixR += (sample*chPanRight[voices[currentVoice].ch])>>7;
        }
    }

    /* TODO: Automatic Gain Control, anyone? */
    /* Or, should this be implemented on the DSP's output volume instead? */

    return;  /* No more ghetto lowpass filter.. linear intrpolation works well. */
}