Envelope in OnAudioFilterRead method

Well, first of all currently you do not create a sine wave as you directly use the phase as data. This would result in a positive only sawtooth wave that would heavily clipping since it goes up to 2PI (6.28). So obviously to get a sine wave you either want to use Mathf.Sin and pass your phase as parameter, or you want to use a "complex phasor" by representing your phase and increment as complex number. If the frequency doesn't change often a complex phasor would probably be better for performance as you only need to use Sin and Cos once when you change the frequency. If you need a complex number type i've once created this one.

An envelope is a bit more complicated. See this post here for a good starting point.

ps: If you're not familiar with complex numbers you can do something like this:

 Complex phase = new Complex(1, 0);
 float m_Frequency;
 Complex increment;
 
 public float Frequency
 {
     get { return m_Frequency;}
     set
     {
         if (value != m_Frequency)
         {
             m_Frequency = value;
             float angle = (m_Frequency * 2.0 * Mathf.PI ) / samplingFq;
             increment = new Complex(Mathf.Cos(angle), Mathf.Sin(angle));
         }
     }
 }
 
 private void OnAudioFilterRead (float[] data, int channels)
 {
     if (channels == 2)
     {
         for (int i = 0; i < data.Length; i += 2)
         {
             phase *= increment;
             data[i] = data[i+1] = phase.fReal;
         }
     }
     else
     {
         for (int i = 0; i < data.Length; i++)
         {
             phase *= increment;
             data[i] = phase.fReal;
         }
     }
     double norm = (3d - phase.real * phase.real - phase.img * phase.img) * 0.5d;
     phase *= norm;
 }

As you can see we just need to calculate sin and cos once when we change the frequency. From now on we can simply "spin" the complex number. Note that the "normalization" at the end is an easy way to avoid drift over time. You could do it within the loops but usually it should be stable for several thousand complex rotations. Note that i splitted the loop into two seperate loops. Doing the if check every iteration is bad for performance. Branch prediction is pretty good nowadays, however it's best to just avoid it in time critical code ^^.