simple Lipsync with microphone input

using UnityEngine; using System.Collections.Generic; using System.Collections;

public class LipSync : MonoBehaviour {

 private Transform mouth;
 private Vector3 initialPos;
 public Vector3 endPos;
 
 private bool initialized = false;
 private bool microphoneClip = false;
 private AudioClip recordedClip;
     
 private const int FREQUENCY = 48000;    
 private const int SAMPLECOUNT = 1024;  
 private const float REFVALUE = 0.1f;    // RMS value for 0 dB.
 private const float THRESHOLD = 0.02f;  // Minimum amplitude to extract pitch (recieve anything)
 
 private float[] samples;           // Samples
 private float[] spectrum;          // Spectrum
 private float rmsValue;            // Volume in RMS
 private float dbValue;             // Volume in DB
 private float pitchValue;          // Pitch - Hz (is this frequency?)
 public int clamp = 160;            // Used to clamp dB
 
 private float time;
 private float elapsedTime;
 
 public void Init ()
 {
     if(initialized)
         return;
     samples = new float[SAMPLECOUNT];
     spectrum = new float[SAMPLECOUNT];
     
     mouth = transform;
     initialPos = mouth.localPosition;
     if (audio == null)
         gameObject.AddComponent<AudioSource> ();
     audio.playOnAwake = false;
     audio.loop = false;
     enabled = false;
     initialized = true;
 }
 
 public void StartClipLipSync (AudioClip clip, bool fromMicrophone)
 {
     Init ();
     audio.clip = clip;
     audio.Play ();
     enabled = true;
     microphoneClip = fromMicrophone;
     Debug.Log ("Clip started for " + transform.root.gameObject.name);
 }
 
 public float PauseClip ()
 {
     audio.Pause ();
     return audio.time;
 }
 
 public void StopClip ()
 {
     Init ();
     audio.Stop ();
 }
 
 public void RestartClip (AudioClip clip, float t)
 {
     Init ();
     audio.clip = clip;
     audio.time = t;
     audio.Play ();
 }
 
 public void RestartClip (float t)
 {
     Init ();
     audio.time = t;
     audio.Play ();
 }
 
 public void RestartClip ()
 {
     Init ();
     audio.Stop ();
     audio.Play ();
 }
 
 // Use this for initialization
 public void StartMicrophoneLipSync ()
 {
     
     Init ();
     
     if (Microphone.devices.Length > 0) {
         audio.clip = Microphone.Start ("Built-in Microphone", true, 999, 44100);
         while (!(Microphone.GetPosition("Built-in Microphone") > 0)) {
         }
         audio.Play ();
         audio.mute = true;
         enabled = true;
         Debug.Log ("Microphone started for " + transform.root.gameObject.name);
     } else
         enabled = false;
     
     microphoneClip = true;
 }
 
 public AudioClip GetRecordedClip ()
 {
     return recordedClip;
 }
 
 void OnDestroy ()
 {
     if (Microphone.IsRecording (null))
         Microphone.End (null);
     Destroy (audio);
 }
 
 public void StopMicrophone ()
 {
     if (audio == null)
         return;
     if (Microphone.IsRecording (null))
         Microphone.End (null);
     recordedClip = audio.clip;
     DestroyImmediate (audio);
     initialized = false;
 }

 
 //This could be programmed as InvokeRepeating
 void Update ()
 {
     AnalyzeSound();
     
     if (mouth == null)
         return;
     
     float freq = HumanFreq(200,800)*1000;
     if(freq>2 && freq <50) {
         
         float step = Mathf.SmoothStep(0, 1, Mathf.SmoothStep(0, 1, elapsedTime/time));
         mouth.localPosition = Vector3.Lerp(initialPos, endPos,step);
         elapsedTime += Time.deltaTime;
     } else {
         mouth.localPosition = initialPos;
         time = 0.3f;
         elapsedTime = 0;
     }
 }
 
 /// Analyzes the sound, to get volume and pitch values.
 private void AnalyzeSound ()
 {
     if(audio==null)
         return;
     // Get all of our samples from the mic.
     audio.GetOutputData (samples, 0);

     // Sums squared samples
     float sum = 0;
     for (int i = 0; i < SAMPLECOUNT; i++) {
         sum += Mathf.Pow (samples [i], 2);
     }

     // RMS is the square root of the average value of the samples.
     rmsValue = Mathf.Sqrt (sum / SAMPLECOUNT);
     dbValue = 20 * Mathf.Log10 (rmsValue / REFVALUE);

     // Clamp it to {clamp} min
     if (dbValue < -clamp) {
         dbValue = -clamp;
     }

     // Gets the sound spectrum.
     audio.GetSpectrumData (spectrum, 0, FFTWindow.BlackmanHarris);
     float maxV = 0;
     int maxN = 0;

     // Find the highest sample.
     for (int i = 0; i < SAMPLECOUNT; i++) {
         if (spectrum [i] > maxV && spectrum [i] > THRESHOLD) {
             maxV = spectrum [i];
             maxN = i; // maxN is the index of max
         }
     }

     // Pass the index to a float variable
     float freqN = maxN;

     // Interpolate index using neighbours
     if (maxN > 0 && maxN < SAMPLECOUNT - 1) {
         float dL = spectrum [maxN - 1] / spectrum [maxN];
         float dR = spectrum [maxN + 1] / spectrum [maxN];
         freqN += 0.5f * (dR * dR - dL * dL);
     }

     // Convert index to frequency
     pitchValue = freqN * 24000 / SAMPLECOUNT;
 }
 private float HumanFreq (float fLow, float fHigh)
 {
     int n1 = (int)Mathf.Floor (fLow * SAMPLECOUNT * 2 / FREQUENCY);
     int n2 = (int)Mathf.Floor (fHigh * SAMPLECOUNT * 2 / FREQUENCY);
     float sum = 0;
     // average the volumes of frequencies fLow to fHigh
     for (var i=n1; i<=n2; i++) {
         sum += spectrum [i];
     }
     return sum / (n2 - n1 + 1);
 }

}

By the way, I give the most credit to @Riro, as I basically just rewrote his script in http://goo.gl/oLTp5