自动判断mic设备

主要从3个方面判断，振幅，信噪比和输出频率

MediaPlayer mMediaPlayer;
Visualizer  mVisualizer;
OnDataCaptureListener captureDataLister;
static final SampleRate, IgnoreHZ, mOldMaxValue, fSourceSoundHz, TolerantRate, SNRPassPercentage;
public void playTrackToVisualizer（String paramString）{
    mMediaPlayer = MediaPlayer.create(getApplicationContext(), Uri.parse(paramString));
    mVisualizer = new Visualizer(mMediaPlayer.getAudioSessionId());
    mVisualizer.setDataCaptureListener(this.captureDataLister, Visualizer.getMaxCaptureRate(), true, true);
    mVisualizer.setEnabled(true);
    mMediaPlayer.start();
}

captureDataLister = new Visualizer.OnDataCaptureListener()
{
      public void onFftDataCapture(Visualizer paramAnonymousVisualizer, byte[] paramAnonymousArrayOfByte, int paramAnonymousInt)
      {
        mMap.put(countFftDataCapture, paramAnonymousArrayOfByte);
        countFftDataCapture++;
      }


      public void onWaveFormDataCapture(Visualizer paramAnonymousVisualizer, byte[] paramAnonymousArrayOfByte, int paramAnonymousInt)
      {
         int m;
         for(int i = 0; i < paramAnonymousArrayOfByte.length; i++){
             m = max(m, paramAnonymousArrayOfByte[i], mOldMaxValue)
         }
         mAmplitudeMap.put(countFftDataCapture, paramAnonymousArrayOfByte);
         countAmplitudeDataCapture++;        
      }
};
  
public void generateFFTData(int paramInt, byte[] paramArrayOfByte)
{
	byte[] arrayOfByte = new byte[paramArrayOfByte.length];
	for (int i = 0; i < paramArrayOfByte.length; i++)
	{
	  paramArrayOfByte[i] = ((byte)checkIgnoreHZ(i, paramArrayOfByte, SampleRate, IgnoreHZ));
	  arrayOfByte[i] = 0;
	}
	for (int j = 1; j < paramArrayOfByte.length - 1; j++)
	  arrayOfByte[j] = Math.hypot(paramArrayOfByte[j], paramArrayOfByte[(j + 1)]);
  	mFFTMap.put(paramInt, arrayOfByte);
}

public float calculateFourierKHZ(int paramInt1, int paramInt2)
{
	return 1000.0F * (paramInt1 / (paramInt2 / 1000000.0F));
}

public float checkIgnoreHZ(int paramInt1, byte[] paramArrayOfByte, int paramInt2, float paramFloat)
{
	return (calculateFourierKHZ(paramInt1, paramInt2) < paramFloat) ? 0.0F : paramInt1;
}

public boolean checkAmplitude(){
    int j;
    for(int i = 0; i < mAmplitudeMap.size(); i++)
         j += mAmplitudeMap.get(i);
      j = j / this.mAmplitudeMap.size();
	mAmplitudeResult = j;
    if( j < MiniAmplitude)
        return false;
    return true;
}

public double checkFFTData(){
	int number = 0;
	double d;
	double af;
    for(int i = 0; i < mMap.size(); i++){
        byte[] arrayOfByte = mMap.get(i);
        generateFFTData(i, arrayOfByte);
        for (int k = 0; k < arrayOfByte.length ; k++)
             arrayOfByte[k] = checkIgnoreHZ(k, arrayOfByte, SampleRate, IgnoreHZ));   
        int n = arrayOfByte[1];
        int p;
        for(int k = 1; k < arrayOfByte.length; k ++){
		    if( n < Math.hypot(arrayOfByte[k], arrayOfByte[(k + 1)])){
				n = Math.hypot(arrayOfByte[k], arrayOfByte[(k + 1)]);
				p = k;
		    }
        }
        double d1 = (fSourceSoundHz + TolerantRate) / 1000.0F * (SampleRate / 1000000.0D);
        double d2 = (fSourceSoundHz  - TolerantRate) / 1000.0F * (SampleRate / 1000000.0D); 
        if( p >= d1 && p <=d2){
            number++;
			d +=p;
			af = (int)d/number;	
        }
    }
	
	return 1000.0D * (af / (SampleRate / 1000000.0));
}

public boolean checkFrequency()
{
	double d = checkFFTData();
	if ((d > fSourceSoundHz - TolerantRate) && (d < fSourceSoundHz + TolerantRate)){
		mFrequencyResult = fSourceSoundHz;
		return true;
	}
	else{
		mFrequencyResult = d;
		return false;
	}
}

public boolean analysisSNR()
{
    HashMap localHashMap1 = new HashMap();
    HashMap localHashMap2 = new HashMap();
    int i = 0;
    HashMap localHashMap3 = new HashMap();
    float f3;
	for (int j = 0; j < mFFTMap.size(); j++)
	{
		f3 = 0.0F;
		int i3 = 0;
		byte[] arrayOfByte = mFFTMap.get(j);
		int[] arrayOfInt = new int[arrayOfByte.length];
		float[] arrayOfFloat = new float[arrayOfByte.length];

		for (int i = 0; i < arrayOfByte.length; i++)
		{
			arrayOfInt[i] = i;
			arrayOfFloat[i] = arrayOfByte[i];
		}

		for (int i = 0; i < arrayOfByte.length - 9; i++)
		{
			float f7 = arrayOfFloat[i];
			float f8 = arrayOfFloat[(i + 1)];
			float f9 = arrayOfFloat[(i + 2)];
			float f10 = arrayOfFloat[(i + 3)];
			float f11 = arrayOfFloat[(i + 4)];
			float f12 = arrayOfFloat[(i + 5)];
			float f13 = arrayOfFloat[(i + 6)];
			float f14 = arrayOfFloat[(i + 7)];
			float f15 = arrayOfFloat[(i + 8)];
			if ((f11 > f7) && (f11 > f8) && (f11 > f9) && (f11 > f10) && (f11 > f12) && (f11 > f13) && (f11 > f14) && (f11 > f15))
			{
				localHashMap1.put(i3, (i + 4));
				localHashMap2.put(i3, f11);
				i3++;
				f3 = (float)(f3 + Math.pow(f11, 2.0D));
			}
		}

		float f4 = 0;
		for(int i = 0; i < localHashMap2.size(); i++){
			f4 = Math.max(f4, localHashMap2.get(i));
		}
		float f5 = f3 - Math.pow(f4, 2.0D);
		float f6 = 10.0D * Math.log10(f3 / f5);
		localHashMap3.put(Integer.valueOf(i), Float.valueOf(f6));
		i++;
		localHashMap1.clear();
		localHashMap2.clear();
    }

	int m = 0;
    int n = 0;
    float f1 = 0.0F;
    for(int i = 0; i < localHashMap3.size(); i++)
    {
		if(localHashMap3.get(i) < SNRRate)
			m++;
		else{
			f1 += localHashMap3.get(i);
			n++;
		}
	}

    mSNRResult = f1 / localHashMap3.size();
    localHashMap3.clear();

    if (n / (n + m) > SNRPassPercentage)
		return true;
	else
		return false;
}