Unity之录音并输出为wav/mp3

在VIVE Focus3中有项目验证通过

一、原理简述

使用Microphone进行音频录制并输出为AudioClip，再把AudioClip的Samples数据通过文件流的方式写入到wav或者mp3文件中。

二、源码展示

• AudioClip转换为wav/mp3

//  http://forum.unity3d.com/threads/119295-Writing-AudioListener.GetOutputData-to-wav-problem?p=806734&viewfull=1#post806734

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

public static class AudioClipConverter
{
    const int HEADER_SIZE = 44;

    /// <summary>
    /// 把AudioClip转换为wav或者mp3
    /// </summary>
    /// <param name="filePath"></param>
    /// <param name="clip"></param>
    public static void Save(string filePath, AudioClip clip)
    {
        Directory.CreateDirectory(Path.GetDirectoryName(filePath) ?? string.Empty);

        var fileStream = CreateEmpty(filePath);
        ConvertAndWrite(fileStream, clip);
        WriteHeader(fileStream, clip);
    }

    /// <summary>
    /// 剔除沉默音域
    /// </summary>
    /// <param name="clip"></param>
    /// <param name="min"></param>
    /// <returns></returns>
    public static AudioClip TrimSilence(AudioClip clip, float min)
    {
        var samples = new float[clip.samples];
        clip.GetData(samples, 0);

        return TrimSilence(new List<float>(samples), min, clip.channels, clip.frequency);
    }

    static AudioClip TrimSilence(List<float> samples, float min, int channels, int hz, bool _3D = false, bool stream = false)
    {
        int origSamples = samples.Count;

        int i;

        for (i = 0; i < samples.Count; i++)
        {
            if (Mathf.Abs(samples[i]) > min)
            {
                break;
            }
        }

        i -= (int) (hz * .1f);
        i = Mathf.Max(i, 0);

        // Remove start silence
        samples.RemoveRange(0, i);

        for (i = samples.Count - 1; i > 0; i--)
        {
            if (Mathf.Abs(samples[i]) > min)
            {
                break;
            }
        }

        // Add some tail onto it
        i += (int) (hz * .1f);
        i = Mathf.Min(i, samples.Count - 1);
        samples.RemoveRange(i, samples.Count - i);


        if (samples.Count == 0)
        {
            Debug.Log("剔除后的AudioClip长度为0");
            return null;
        }

        var clip = AudioClip.Create("TempClip", samples.Count, channels, hz, _3D, stream);
        clip.SetData(samples.ToArray(), 0);

        return clip;
    }

    static FileStream CreateEmpty(string filepath)
    {
        var fileStream = new FileStream(filepath, FileMode.Create);
        byte emptyByte = new byte();

        //preparing the header
        for (int i = 0; i < HEADER_SIZE; i++) 
        {
            fileStream.WriteByte(emptyByte);
        }

        return fileStream;
    }

    static void ConvertAndWrite(FileStream fileStream, AudioClip clip)
    {
        var samples = new float[clip.samples];
        clip.GetData(samples, 0);

        Int16[] intData = new Int16[samples.Length];
        //converting in 2 float[] steps to Int16[], //then Int16[] to Byte[]

        Byte[] bytesData = new Byte[samples.Length * 2];
        //bytesData array is twice the size of
        //dataSource array because a float converted in Int16 is 2 bytes.

        int rescaleFactor = 32767; //to convert float to Int16

        for (int i = 0; i < samples.Length; i++)
        {
            intData[i] = (short) (samples[i] * rescaleFactor);
            Byte[] byteArr = new Byte[2];
            byteArr = BitConverter.GetBytes(intData[i]);
            byteArr.CopyTo(bytesData, i * 2);
        }

        fileStream.Write(bytesData, 0, bytesData.Length);
    }

    static void WriteHeader(FileStream fileStream, AudioClip clip)
    {
        var hz = clip.frequency;
        var channels = clip.channels;
        var samples = clip.samples;

        fileStream.Seek(0, SeekOrigin.Begin);

        Byte[] riff = System.Text.Encoding.UTF8.GetBytes("RIFF");
        fileStream.Write(riff, 0, 4);

        Byte[] chunkSize = BitConverter.GetBytes(fileStream.Length - 8);
        fileStream.Write(chunkSize, 0, 4);

        Byte[] wave = System.Text.Encoding.UTF8.GetBytes("WAVE");
        fileStream.Write(wave, 0, 4);

        Byte[] fmt = System.Text.Encoding.UTF8.GetBytes("fmt ");
        fileStream.Write(fmt, 0, 4);

        Byte[] subChunk1 = BitConverter.GetBytes(16);
        fileStream.Write(subChunk1, 0, 4);

        UInt16 two = 2;
        UInt16 one = 1;

        Byte[] audioFormat = BitConverter.GetBytes(one);
        fileStream.Write(audioFormat, 0, 2);

        Byte[] numChannels = BitConverter.GetBytes(channels);
        fileStream.Write(numChannels, 0, 2);

        Byte[] sampleRate = BitConverter.GetBytes(hz);
        fileStream.Write(sampleRate, 0, 4);

        // sampleRate * bytesPerSample*number of channels, here 44100*2*2
        Byte[] byteRate = BitConverter.GetBytes(hz * channels * 2); 
        fileStream.Write(byteRate, 0, 4);

        UInt16 blockAlign = (ushort) (channels * 2);
        fileStream.Write(BitConverter.GetBytes(blockAlign), 0, 2);

        UInt16 bps = 16;
        Byte[] bitsPerSample = BitConverter.GetBytes(bps);
        fileStream.Write(bitsPerSample, 0, 2);

        Byte[] datastring = System.Text.Encoding.UTF8.GetBytes("data");
        fileStream.Write(datastring, 0, 4);

        Byte[] subChunk2 = BitConverter.GetBytes(samples * channels * 2);
        fileStream.Write(subChunk2, 0, 4);

        fileStream.Close();
    }
}

• 业务代码，核心在使用Microphone那一部分

using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class AudioRecordManager : MonoBehaviour
{
    private const int MaxDuration = 120;
    private const float TrimCutOff = 0.01f;
    private const int SampleRate = 44100;

    private bool isRecording;
    private AudioClip clip;
    private string deviceName;

    [SerializeField] private Button recordingBtn;
    private Image recordingImg;
    [SerializeField] private Sprite recordingCloseSp, recordingOpenSp;
    
    private float recordingTimer;

    private void Awake()
    {
        recordingImg = recordingBtn.GetComponent<Image>();
        deviceName = Microphone.devices[0];
    }

    private void Start()
    {
        OnClickRecordingBtn();
    }

    private void Update()
    {
        StopWhenTimeout();
    }

    void StopWhenTimeout()
    {
        if (isRecording)
        {
            recordingTimer += Time.deltaTime;
            
            if ((int) recordingTimer >= MaxDuration)
            {
                recordingTimer = 0;
                OnClickRecordingBtn();
            }
        }
    }
    
    private void OnClickRecordingBtn()
    {
        if (recordingBtn != null)
        {
            recordingBtn.onClick.AddListener(delegate
            {
                isRecording = !isRecording;
                recordingImg.sprite = isRecording ? recordingOpenSp : recordingCloseSp;

                if (isRecording)
                {
                    clip = Microphone.Start(deviceName, true, MaxDuration, SampleRate);
                }
                else
                {
                    Microphone.End(deviceName);
                    AudioClip tmp = AudioClipConverter.TrimSilence(clip, TrimCutOff);
                    AudioClipConverter.Save(GetFilePath(), tmp);
                }
            });
        }
    }

    private string GetFilePath()
    {
        return Application.streamingAssetsPath + "/" + SceneManager.GetActiveScene().name + ".mp3";
    }
}