WavePacket.h

/*
 * WavePacket.h
 *
 * Copyright 2013 Tim Barrass.
 *
 * This file is part of Mozzi.
 *
 * Mozzi is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.
 *
 */


#ifndef WAVEPACKET_H
#define WAVEPACKET_H

#include <MozziGuts.h>
#include <Oscil.h>
#include <tables/cos8192_int8.h>
#include <mozzi_fixmath.h>
#include <Phasor.h>
#include <Line.h>
#include <meta.h>


enum algorithms {SINGLE,DOUBLE};

/**
Wavepacket synthesis, with two overlapping streams of wave packets. Draws on
Miller Puckette's Pure Data example, F14.wave.packet.pd. Each packet is an
enveloped grain of a sin (or cos) wave. The frequency of the wave, the width of
the envelopes and the rate of release of envelopes are the parameters which can
be changed.
@tparam ALGORITHM options are SINGLE or DOUBLE, for a single non-overlapping stream of packets or a double, overlapping stream.
*/
template <int8_t ALGORITHM>
class WavePacket
{
public:

    /** Constructor.
    */
    WavePacket():AUDIO_STEPS_PER_CONTROL(AUDIO_RATE / CONTROL_RATE)
    {
        aCos.setTable(COS8192_DATA);
    }


    /** Set all the parameters for the synthesis.
    The function is designed so that usable ranges for parameters can come from analog inputs, ie. 0-1023.
    @param fundamental the rate at which packets are produced.
    @param bandwidth the width of each packet.  A lower value allows more 
    of the centre frequency to be audible, a rounder sound.  
    A higher value produces narrower packets, a more buzzing sound.
    @param centrefreq the oscillation frequency within each packet.
    */
    inline
    void set(int fundamental, int bandwidth, int centrefreq)
    {
        setFundamental(fundamental);
        setBandwidth(bandwidth);
        setCentreFreq(centrefreq);
    }


    /** Set the fundamental frequency.
    The function is designed so that usable ranges for parameters can come from analog inputs, ie. 0-1023.
    @param fundamental the rate at which packets are produced.
    */
    inline
    void setFundamental(int fundamental)
    {
        aPhasor.setFreq(fundamental);
        invFreq = Q8n24_FIX1 / fundamental;
    }



    /** Set the bandwidth.
    The function is designed so that usable ranges for parameters can come from analog inputs, ie. 0-1023.
    @param bandwidth the width of each packet.  A lower value allows more of the 
    centre frequency to be audible, a rounder sound.  
    A higher value produces narrower packets, a more buzzing sound.
    */
    inline
    void setBandwidth(int bandwidth)
    {
        Q15n16 bw = invFreq*bandwidth;
        bw >>= 9;
        bw = max(bw, Q15n16_FIX1>>3);
        aBandwidth.set(bw, AUDIO_STEPS_PER_CONTROL);
    }



    /** Set the centre frequency.
    The function is designed so that usable ranges for parameters can come from analog inputs, ie. 0-1023.
    @param centrefreq the oscillation frequency within each packet.
    */
    inline
    void setCentreFreq(int centrefreq)
    {
        Q15n16 cf = invFreq * centrefreq;
        cf >>= 3;
        aCentrefreq.set(cf, AUDIO_STEPS_PER_CONTROL);
    }


/** Calculate the next synthesised sample.
@return a full-scale 16 bit value, which needs to be scaled to suit your sketch.  If you're using it straight as the sketch output,
then that will be yourThing.next()>>2 for HIFI 14 bit output, or >>8 for STANDARD 8+ bit output.
*/
    inline
    int next()
    {
        gcentrefreq = aCentrefreq.next();
        gbandwidth = aBandwidth.next();
        int phase1 = aPhasor.next()>>16; // -0.5 to 0.5, 0n15
        if (ALGORITHM == DOUBLE) {
            return (signalPath(params1, phase1)+signalPath(params2, phase1+32768))>>1;
        } else {
            return signalPath(params1, phase1);
        }
    }



private:
    //Q15n16 fundamental; // range 4 to 6271 in pd patch, 13 integer bits
    Q8n24 invFreq;
    Q15n16 gcentrefreq;   // range 0 to 3068, 12 integer bits
    Q15n16 gbandwidth;   // range 1 to 3068, 12 integer bits

    // Lines to interpolate controls at audio rate
    Line <Q15n16> aCentrefreq;
    Line <Q16n16> aBandwidth;
    Line <Q16n16> aFreq;

    // different sets of params for each audio phase stream
    struct parameters
    {
        int previous_phase;
        Q15n16 centrefreq;
        Q23n8 bandwidth;
    }
    params1,params2;

    // the number of audio steps the line has to take to reach the next control value
    const unsigned int AUDIO_STEPS_PER_CONTROL;

    Oscil <COS8192_NUM_CELLS, AUDIO_RATE> aCos;
    Phasor <AUDIO_RATE> aPhasor;


    inline
    int signalPath(struct parameters &param, int phase) // 25us?  * 2
    {
        //setPin13High();
        int index;

        if(phase<param.previous_phase)
        {
            param.centrefreq = gcentrefreq>>8;
            param.bandwidth = Q15n16_to_Q23n8(gbandwidth);
        }
        param.previous_phase = phase;

        // oscillation
        index = (param.centrefreq * phase)>>16;
        // hack to make peak in middle of packet, otherwise it centres around a zero-crossing.. 
        index += COS8192_NUM_CELLS>>1;
        index &= COS8192_NUM_CELLS-1;
        int8_t sig1 = aCos.atIndex(index);

        // packet envelope
        Q23n8 bwphase = (param.bandwidth * phase)>>8;
        bwphase += COS8192_NUM_CELLS>>1;
        index = constrain(bwphase, 0, (COS8192_NUM_CELLS-1));
        uint8_t packet_width = 128 + aCos.atIndex(index);
        // if (AUDIO_MODE == HIFI){
            // return ((int) sig1 * packet_width)>>3; // scaled to fit HIFI updateAudio output
        // }else{
            // return ((int) sig1 * packet_width)>>8; // scaled to fit STANDARD updateAudio output
        // }

        return ((int) sig1 * packet_width);
    }

};

/** @example 06.Synthesis/WavePacket/WavePacket.ino
This is an example of how to use the WavePacket class.
*/

#endif        //  #ifndef WAVEPACKET_H