Unity中用于录制和音频播放功能的WAV实用程序。

最新推荐文章于 2023-07-29 12:56:44 发布
最新推荐文章于 2023-07-29 12:56:44 发布
阅读量253 收藏
点赞数
分类专栏： U3d 知识点记录 文章标签： unity 音视频 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50702814/article/details/130709222
版权 
using UnityEngine;
using System.Text;
using System.IO;
using System;

/// <summary>
/// WAV utility for recording and audio playback functions in Unity.
/// Version: 1.0 alpha 1
///
/// - Use "ToAudioClip" method for loading wav file / bytes.
/// Loads .wav (PCM uncompressed) files at 8,16,24 and 32 bits and converts data to Unity's AudioClip.
///
/// - Use "FromAudioClip" method for saving wav file / bytes.
/// Converts an AudioClip's float data into wav byte array at 16 bit.
/// </summary>
/// <remarks>
/// For documentation and usage examples: https://github.com/deadlyfingers/UnityWav
/// </remarks>

public class WavUtility
{
	// Force save as 16-bit .wav
	const int BlockSize_16Bit = 2;

	/// <summary>
	/// Load PCM format *.wav audio file (using Unity's Application data path) and convert to AudioClip.
	/// </summary>
	/// <returns>The AudioClip.</returns>
	/// <param name="filePath">Local file path to .wav file</param>
	public static AudioClip ToAudioClip(string filePath)
	{
		if (!filePath.StartsWith(Application.persistentDataPath) && !filePath.StartsWith(Application.dataPath))
		{
			Debug.LogWarning("This only supports files that are stored using Unity's Application data path. \nTo load bundled resources use 'Resources.Load(\"filename\") typeof(AudioClip)' method. \nhttps://docs.unity3d.com/ScriptReference/Resources.Load.html");
			return null;
		}
		byte[] fileBytes = File.ReadAllBytes(filePath);
		return ToAudioClip(fileBytes, 0);
	}

	public static AudioClip ToAudioClip(byte[] fileBytes, int offsetSamples = 0, string name = "wav")
	{
		//string riff = Encoding.ASCII.GetString (fileBytes, 0, 4);
		//string wave = Encoding.ASCII.GetString (fileBytes, 8, 4);
		int subchunk1 = BitConverter.ToInt32(fileBytes, 16);
		UInt16 audioFormat = BitConverter.ToUInt16(fileBytes, 20);

		// NB: Only uncompressed PCM wav files are supported.
		string formatCode = FormatCode(audioFormat);
		Debug.AssertFormat(audioFormat == 1 || audioFormat == 65534, "Detected format code '{0}' {1}, but only PCM and WaveFormatExtensable uncompressed formats are currently supported.", audioFormat, formatCode);

		UInt16 channels = BitConverter.ToUInt16(fileBytes, 22);
		int sampleRate = BitConverter.ToInt32(fileBytes, 24);
		//int byteRate = BitConverter.ToInt32 (fileBytes, 28);
		//UInt16 blockAlign = BitConverter.ToUInt16 (fileBytes, 32);
		UInt16 bitDepth = BitConverter.ToUInt16(fileBytes, 34);

		int headerOffset = 16 + 4 + subchunk1 + 4;
		int subchunk2 = BitConverter.ToInt32(fileBytes, headerOffset);
		//Debug.LogFormat ("riff={0} wave={1} subchunk1={2} format={3} channels={4} sampleRate={5} byteRate={6} blockAlign={7} bitDepth={8} headerOffset={9} subchunk2={10} filesize={11}", riff, wave, subchunk1, formatCode, channels, sampleRate, byteRate, blockAlign, bitDepth, headerOffset, subchunk2, fileBytes.Length);

		float[] data;
		switch (bitDepth)
		{
			case 8:
				data = Convert8BitByteArrayToAudioClipData(fileBytes, headerOffset, subchunk2);
				break;
			case 16:
				data = Convert16BitByteArrayToAudioClipData(fileBytes, headerOffset, subchunk2);
				break;
			case 24:
				data = Convert24BitByteArrayToAudioClipData(fileBytes, headerOffset, subchunk2);
				break;
			case 32:
				data = Convert32BitByteArrayToAudioClipData(fileBytes, headerOffset, subchunk2);
				break;
			default:
				throw new Exception(bitDepth + " bit depth is not supported.");
		}

		AudioClip audioClip = AudioClip.Create(name, data.Length, (int)channels, sampleRate, false);
		audioClip.SetData(data, 0);
		return audioClip;
	}

	#region wav file bytes to Unity AudioClip conversion methods

	private static float[] Convert8BitByteArrayToAudioClipData(byte[] source, int headerOffset, int dataSize)
	{
		int wavSize = BitConverter.ToInt32(source, headerOffset);
		headerOffset += sizeof(int);
		Debug.AssertFormat(wavSize > 0 && wavSize == dataSize, "Failed to get valid 8-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);

		float[] data = new float[wavSize];

		sbyte maxValue = sbyte.MaxValue;

		int i = 0;
		while (i < wavSize)
		{
			data[i] = (float)source[i] / maxValue;
			++i;
		}

		return data;
	}

	private static float[] Convert16BitByteArrayToAudioClipData(byte[] source, int headerOffset, int dataSize)
	{
		int wavSize = BitConverter.ToInt32(source, headerOffset);
		headerOffset += sizeof(int);
		Debug.AssertFormat(wavSize > 0 && wavSize == dataSize, "Failed to get valid 16-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);

		int x = sizeof(Int16); // block size = 2
		int convertedSize = wavSize / x;

		float[] data = new float[convertedSize];

		Int16 maxValue = Int16.MaxValue;

		int offset = 0;
		int i = 0;
		while (i < convertedSize)
		{
			offset = i * x + headerOffset;
			data[i] = (float)BitConverter.ToInt16(source, offset) / maxValue;
			++i;
		}

		Debug.AssertFormat(data.Length == convertedSize, "AudioClip .wav data is wrong size: {0} == {1}", data.Length, convertedSize);

		return data;
	}

	private static float[] Convert24BitByteArrayToAudioClipData(byte[] source, int headerOffset, int dataSize)
	{
		int wavSize = BitConverter.ToInt32(source, headerOffset);
		headerOffset += sizeof(int);
		Debug.AssertFormat(wavSize > 0 && wavSize == dataSize, "Failed to get valid 24-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);

		int x = 3; // block size = 3
		int convertedSize = wavSize / x;

		int maxValue = Int32.MaxValue;

		float[] data = new float[convertedSize];

		byte[] block = new byte[sizeof(int)]; // using a 4 byte block for copying 3 bytes, then copy bytes with 1 offset

		int offset = 0;
		int i = 0;
		while (i < convertedSize)
		{
			offset = i * x + headerOffset;
			Buffer.BlockCopy(source, offset, block, 1, x);
			data[i] = (float)BitConverter.ToInt32(block, 0) / maxValue;
			++i;
		}

		Debug.AssertFormat(data.Length == convertedSize, "AudioClip .wav data is wrong size: {0} == {1}", data.Length, convertedSize);

		return data;
	}

	private static float[] Convert32BitByteArrayToAudioClipData(byte[] source, int headerOffset, int dataSize)
	{
		int wavSize = BitConverter.ToInt32(source, headerOffset);
		headerOffset += sizeof(int);
		Debug.AssertFormat(wavSize > 0 && wavSize == dataSize, "Failed to get valid 32-bit wav size: {0} from data bytes: {1} at offset: {2}", wavSize, dataSize, headerOffset);

		int x = sizeof(float); //  block size = 4
		int convertedSize = wavSize / x;

		Int32 maxValue = Int32.MaxValue;

		float[] data = new float[convertedSize];

		int offset = 0;
		int i = 0;
		while (i < convertedSize)
		{
			offset = i * x + headerOffset;
			data[i] = (float)BitConverter.ToInt32(source, offset) / maxValue;
			++i;
		}

		Debug.AssertFormat(data.Length == convertedSize, "AudioClip .wav data is wrong size: {0} == {1}", data.Length, convertedSize);

		return data;
	}

	#endregion

	public static byte[] FromAudioClip(AudioClip audioClip)
	{
		string file;
		return FromAudioClip(audioClip, out file, false);
	}

	public static byte[] FromAudioClip(AudioClip audioClip, out string filepath, bool saveAsFile = true, string dirname = "recordings")
	{
		MemoryStream stream = new MemoryStream();

		const int headerSize = 44;

		// get bit depth
		UInt16 bitDepth = 16; //BitDepth (audioClip);

		// NB: Only supports 16 bit
		//Debug.AssertFormat (bitDepth == 16, "Only converting 16 bit is currently supported. The audio clip data is {0} bit.", bitDepth);

		// total file size = 44 bytes for header format and audioClip.samples * factor due to float to Int16 / sbyte conversion
		int fileSize = audioClip.samples * BlockSize_16Bit + headerSize; // BlockSize (bitDepth)

		// chunk descriptor (riff)
		WriteFileHeader(ref stream, fileSize);
		// file header (fmt)
		WriteFileFormat(ref stream, audioClip.channels, audioClip.frequency, bitDepth);
		// data chunks (data)
		WriteFileData(ref stream, audioClip, bitDepth);

		byte[] bytes = stream.ToArray();

		// Validate total bytes
		Debug.AssertFormat(bytes.Length == fileSize, "Unexpected AudioClip to wav format byte count: {0} == {1}", bytes.Length, fileSize);

		// Save file to persistant storage location
		if (saveAsFile)
		{
			filepath = string.Format("{0}/{1}/{2}.{3}", Application.persistentDataPath, dirname, DateTime.UtcNow.ToString("yyMMdd-HHmmss-fff"), "wav");
			Directory.CreateDirectory(Path.GetDirectoryName(filepath));
			File.WriteAllBytes(filepath, bytes);
			//Debug.Log ("Auto-saved .wav file: " + filepath);
		}
		else
		{
			filepath = null;
		}

		stream.Dispose();

		return bytes;
	}

	#region write .wav file functions

	private static int WriteFileHeader(ref MemoryStream stream, int fileSize)
	{
		int count = 0;
		int total = 12;

		// riff chunk id
		byte[] riff = Encoding.ASCII.GetBytes("RIFF");
		count += WriteBytesToMemoryStream(ref stream, riff, "ID");

		// riff chunk size
		int chunkSize = fileSize - 8; // total size - 8 for the other two fields in the header
		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(chunkSize), "CHUNK_SIZE");

		byte[] wave = Encoding.ASCII.GetBytes("WAVE");
		count += WriteBytesToMemoryStream(ref stream, wave, "FORMAT");

		// Validate header
		Debug.AssertFormat(count == total, "Unexpected wav descriptor byte count: {0} == {1}", count, total);

		return count;
	}

	private static int WriteFileFormat(ref MemoryStream stream, int channels, int sampleRate, UInt16 bitDepth)
	{
		int count = 0;
		int total = 24;

		byte[] id = Encoding.ASCII.GetBytes("fmt ");
		count += WriteBytesToMemoryStream(ref stream, id, "FMT_ID");

		int subchunk1Size = 16; // 24 - 8
		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(subchunk1Size), "SUBCHUNK_SIZE");

		UInt16 audioFormat = 1;
		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(audioFormat), "AUDIO_FORMAT");

		UInt16 numChannels = Convert.ToUInt16(channels);
		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(numChannels), "CHANNELS");

		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(sampleRate), "SAMPLE_RATE");

		int byteRate = sampleRate * channels * BytesPerSample(bitDepth);
		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(byteRate), "BYTE_RATE");

		UInt16 blockAlign = Convert.ToUInt16(channels * BytesPerSample(bitDepth));
		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(blockAlign), "BLOCK_ALIGN");

		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(bitDepth), "BITS_PER_SAMPLE");

		// Validate format
		Debug.AssertFormat(count == total, "Unexpected wav fmt byte count: {0} == {1}", count, total);

		return count;
	}

	private static int WriteFileData(ref MemoryStream stream, AudioClip audioClip, UInt16 bitDepth)
	{
		int count = 0;
		int total = 8;

		// Copy float[] data from AudioClip
		float[] data = new float[audioClip.samples * audioClip.channels];
		audioClip.GetData(data, 0);

		byte[] bytes = ConvertAudioClipDataToInt16ByteArray(data);

		byte[] id = Encoding.ASCII.GetBytes("data");
		count += WriteBytesToMemoryStream(ref stream, id, "DATA_ID");

		int subchunk2Size = Convert.ToInt32(audioClip.samples * BlockSize_16Bit); // BlockSize (bitDepth)
		count += WriteBytesToMemoryStream(ref stream, BitConverter.GetBytes(subchunk2Size), "SAMPLES");

		// Validate header
		Debug.AssertFormat(count == total, "Unexpected wav data id byte count: {0} == {1}", count, total);

		// Write bytes to stream
		count += WriteBytesToMemoryStream(ref stream, bytes, "DATA");

		// Validate audio data
		Debug.AssertFormat(bytes.Length == subchunk2Size, "Unexpected AudioClip to wav subchunk2 size: {0} == {1}", bytes.Length, subchunk2Size);

		return count;
	}

	private static byte[] ConvertAudioClipDataToInt16ByteArray(float[] data)
	{
		MemoryStream dataStream = new MemoryStream();

		int x = sizeof(Int16);

		Int16 maxValue = Int16.MaxValue;

		int i = 0;
		while (i < data.Length)
		{
			dataStream.Write(BitConverter.GetBytes(Convert.ToInt16(data[i] * maxValue)), 0, x);
			++i;
		}
		byte[] bytes = dataStream.ToArray();

		// Validate converted bytes
		Debug.AssertFormat(data.Length * x == bytes.Length, "Unexpected float[] to Int16 to byte[] size: {0} == {1}", data.Length * x, bytes.Length);

		dataStream.Dispose();

		return bytes;
	}

	private static int WriteBytesToMemoryStream(ref MemoryStream stream, byte[] bytes, string tag = "")
	{
		int count = bytes.Length;
		stream.Write(bytes, 0, count);
		//Debug.LogFormat ("WAV:{0} wrote {1} bytes.", tag, count);
		return count;
	}

	#endregion

	/// <summary>
	/// Calculates the bit depth of an AudioClip
	/// </summary>
	/// <returns>The bit depth. Should be 8 or 16 or 32 bit.</returns>
	/// <param name="audioClip">Audio clip.</param>
	public static UInt16 BitDepth(AudioClip audioClip)
	{
		UInt16 bitDepth = Convert.ToUInt16(audioClip.samples * audioClip.channels * audioClip.length / audioClip.frequency);
		Debug.AssertFormat(bitDepth == 8 || bitDepth == 16 || bitDepth == 32, "Unexpected AudioClip bit depth: {0}. Expected 8 or 16 or 32 bit.", bitDepth);
		return bitDepth;
	}

	private static int BytesPerSample(UInt16 bitDepth)
	{
		return bitDepth / 8;
	}

	private static int BlockSize(UInt16 bitDepth)
	{
		switch (bitDepth)
		{
			case 32:
				return sizeof(Int32); // 32-bit -> 4 bytes (Int32)
			case 16:
				return sizeof(Int16); // 16-bit -> 2 bytes (Int16)
			case 8:
				return sizeof(sbyte); // 8-bit -> 1 byte (sbyte)
			default:
				throw new Exception(bitDepth + " bit depth is not supported.");
		}
	}

	private static string FormatCode(UInt16 code)
	{
		switch (code)
		{
			case 1:
				return "PCM";
			case 2:
				return "ADPCM";
			case 3:
				return "IEEE";
			case 7:
				return "μ-law";
			case 65534:
				return "WaveFormatExtensable";
			default:
				Debug.LogWarning("Unknown wav code format:" + code);
				return "";
		}
	}

}

链接：GitHub - deadlyfingers/UnityWav: WAV utility for saving and loading wav files in Unity

浅陌sss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Unity】流式播放wav音频
GrimRaider的专栏
03-10 592
wav 文件支持多种不同的比特率、采样率、多声道音频。1.MP3编码格式 1.1.MP3概述 MPEG-1 or MPEG-2 Audio Layer III是一种音频压缩技术，其全称是动态影像专家压缩标准音频层面3（Moving Picture Experts Group Audio Layer III），简称为MP3，是目前最流行的音频编码…因wav文件一般较大，unity本身播放wav时需要完全加载全部文件数据之后才能开始播放。WavFile：重写了wav的解析，用于可以分块多次加载wav文件；
unity录制音频
04-14
里面是一个unitypackage的包 直接拖入unity即可 内含获取麦克风 录制 回放 保存等
Unity加载并播放本地.wav音频文件
qq_44284055的博客
07-29 1888
Unity加载并播放本地.wav音频文件。
【Unity】流式播放远端音频：WAV格式音频篇（一）
GrimRaider的专栏
02-02 1475
unity流式播放远端wav音频
Unity 录音
白羊兽瞳
04-19 589
using UnityEngine; using System; using System.IO; /// /// 音频扩展 /// public static class AudioClipExtension { private static AudioClip clip; private static int maxRecordTime = 10; private st
Unity5.5 麦克风录音并播放MP3
03-31
这是一个用C#编写的Unity资源包，可以录制麦克风的语音输入，转换成MP3和WAV格式，还可以播放本地的MP3和WAV格式的音频文件，导入后如果报错，请修改.NET API File => Build Settings => Player Settings => (in ...
StorageServicesDemo：用于使用Azure Blob存储保存和加载图像，音频，xml，json和资产捆绑的Unity演示
02-05
捕获PNG屏幕截图（图像Blob） 录制.WAV音频剪辑（音频Blob） 保存和加载.unity资产捆绑包（二进制Blob） 保存/加载XML文件以将Asset Bundle预制件加载到场景保存/加载JSON文件以将Asset Bundle预制件加载到场景列出...
unity本地录音并保存本地源码项目 支持pc和Android端
最新发布
03-25
AudioSource是播放音频的组件，而AudioRecorder则用于录制音频。在这个项目中，源码可能包含了启动、停止录音的函数，以及设置录音参数的代码。例如，开发者可能会用到`Microphone.Start()`和`Microphone.End()`来...
Unity Recorder
08-21
Unity Recorder是Unity引擎提供的一款强大的官方插件，主要用于在Unity环境中录制游戏场景的动画片段和视频。这款工具的出现使得开发者能够轻松地捕获游戏的实时动态，为游戏预告、教程制作、用户反馈或者游戏开发...
测试NAudio获取大多数音频文件的时间长度
05-16
NAudio是.NET Framework下的一款强大的音频处理库，它允许开发者在C#中处理各种音频文件，包括播放、录制、分析和转换。在这个测试项目中，我们主要关注的是如何使用NAudio来获取音频文件的时间长度，这是一个非常...
unity的Microphone录音
12-05
Microphone包含开始录音，停止录音，播放录音以及录音的保存等。
unity录音功能并上传
11-23
使用unityAPI实现实时录音并生成MP3,分段上传到服务器
Unity保存录音实际长度并分段上传服务器
11-26
接到这个需求后先查看了网友们的教程,但大多数都是设定一个固定录音时长,即使是录音实际长度为几秒钟,但是生成文件的大小却是按照最大录音时长来生成,因此本人整理了一下代码,实现自由录音时长,并分段上传到服务器.
Unity使用MicroPhone类调用麦克风录音
天富儿的博客
08-09 5072
Unity使用MicroPhone类调用麦克风录音`MicroPhone`类注意代码实例参考链接 MicroPhone类 使用这个类可以使用连接的麦克风录制到AudioClip。 您可以从devices属性中获取已连接麦克风的列表，然后使用Start和End函数使用一个可用设备启动或结束录制会话。 注意 Microphone类录取保存到AudioClip中的格式为PCM格式默认16000hz、16位、单通道，这些属性在转码时很关键。不管你是自己从Unity中拖音频文件到AudioClip中还是用Unity
unity实现录音功能
赖张殷-Eagle
12-07 2675
using UnityEngine; using System.Collections; using System.Collections.Generic; public class AudioTest : MonoBehaviour { private AudioSource _AudioSource; public AudioSource myAudioSource
Unity+chatgpt+webgl实现声音录制+语音识别
sinat_28962939的博客
07-22 2993
AI二次元女友这个项目持续更新，在window端的语音识别和语音合成的功能，在上一篇博文里已经详细说明了微软Azure语音服务的代码实现。也是为了实现一次代码，多端复用这样的诉求，所以全部的代码实现都改成了web api的方式。然而在实测发布到webgl的时候，就发现了一个问题，因为这个项目涉及到麦克风录制声音，用作语音识别，结果在发布的时候，引擎报错，提示unity发布到webgl失败了，查了一下相关资料，原来是unity内置的microphone类是不支持webgl了，所以只好另找解决方案。
Unity mp3转wav
VAIN的博客
05-27 844
介绍 unity的WWW或者UnityWebRequest无法加载MP3格式的，就需要我们将MP3转成WAV或者其他可用的格式。这里使用了NAudio.dll 引用 using NAudio.Wave; /// <summary> /// UnityWebRequest 加载MP3播放 /// </summary> /// <param name="url"></param> /// <param name="a
unity自动录音功能
dead1ine的博客
12-11 648
using System.Collections.Generic;   using UnityEngine;      namespace Moka   {       internal class TalkingTom       {           //每秒种产生0.4M数据量           private readonly LinkedListfloat> reco
Unity外部读取音乐，mp3、wav
qq1303061229的博客
06-04 3017
话不多说，代码直接上，需要的Dll我会放下面链接里，代码复制直接可用 using System.Collections; using System.Collections.Generic; using System.IO; using UnityEngine; using NAudio.Wave; public class GetAudio : MonoBehaviour { public AudioSource audioSource; private void Awake() ...
unity录制视频和音频
06-08
Unity 中可以使用第三方插件来录制视频和音频。以下是一些常用的插件： 1. Cinemachine：Cinemachine 是 Unity 的一个相机系统，它可以用于创建复杂的相机运动和布置摄像头。在 Cinemachine 中，可以使用 Virtual ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值