/// <summary>
/// Applies audio sample rate to all audio files within the supplied directory. (non recursive)
/// </summary>
/// <param name="path">The path to search</param>
/// <param name="sampleRate">The sample rate to apply to audio files</param>
private static void ApplyAudioSampleRate(string path, int sampleRate)
{
var assets = HelperFunctions.FindAssetsByType <AudioClip>(path);
for (int i = 0; i < assets.Count; i++)
{
try
{
var importer = AssetImporter.GetAtPath(assets[i].path);
AudioImporter audioImporter = (AudioImporter)importer;
AudioImporterSampleSettings audioImporterSampleSettings = audioImporter.defaultSampleSettings;
audioImporterSampleSettings.sampleRateSetting = AudioSampleRateSetting.OverrideSampleRate;
audioImporterSampleSettings.sampleRateOverride = Convert.ToUInt32(sampleRate);
audioImporter.defaultSampleSettings = audioImporterSampleSettings;
importer.SaveAndReimport();
}
catch
{
Debug.LogError("Invalid audio sample rate");
}
}
}
/// <summary>
/// Applies audio compression format settings to all audio files within the supplied directory. (non recursive)
/// </summary>
/// <param name="path">The path to search</param>
/// <param name="format">The desired load format. Please see Keys.AudioCompressionFormats for more</param>
private static void ApplyAudioCompressionFormat(string path, int format)
{
var assets = HelperFunctions.FindAssetsByType <AudioClip>(path);
for (int i = 0; i < assets.Count; i++)
{
Preset preset = new Preset((AudioClip)assets[i].asset);
var importer = AssetImporter.GetAtPath(assets[i].path);
AudioImporter audioImporter = (AudioImporter)importer;
AudioImporterSampleSettings audioImporterSampleSettings = audioImporter.defaultSampleSettings;
try
{
audioImporterSampleSettings.compressionFormat = Keys.AudioCompressionFormats[format];
audioImporter.defaultSampleSettings = audioImporterSampleSettings;
bool result = preset.ApplyTo(importer);
importer.SaveAndReimport();
}
catch
{
Debug.LogError("Invalid Audio Compression Format");
}
}
}
/// <summary>
/// Applies audio load type to all audio files within the supplied directory. (non recursive)
/// </summary>
/// <param name="path">The path to search</param>
/// <param name="loadType">The desired load type for audio files. See Keys.AudioClipLoadTypes for more</param>
private static void ApplyAudioLoadType(string path, int loadType)
{
var assets = HelperFunctions.FindAssetsByType <AudioClip>(path);
for (int i = 0; i < assets.Count; i++)
{
try
{
var importer = AssetImporter.GetAtPath(assets[i].path);
AudioImporter audioImporter = (AudioImporter)importer;
AudioImporterSampleSettings audioImporterSampleSettings = audioImporter.defaultSampleSettings;
audioImporterSampleSettings.loadType = Keys.AudioClipLoadTypes[loadType];
audioImporter.defaultSampleSettings = audioImporterSampleSettings;
importer.SaveAndReimport();
}
catch
{
Debug.LogError("Invalid Audio Load Type");
}
}
}
void OnPreprocessAudio()
{
if (assetPath.Contains("Background"))
{
var sampleSettings = new AudioImporterSampleSettings();
var fileSize = new FileInfo(assetPath).Length / 1024;
sampleSettings.compressionFormat = AudioCompressionFormat.Vorbis;
if (fileSize < 200)
{
sampleSettings.loadType = AudioClipLoadType.DecompressOnLoad;
}
else if (fileSize > 5000)
{
sampleSettings.loadType = AudioClipLoadType.Streaming;
}
else
{
sampleSettings.loadType = AudioClipLoadType.CompressedInMemory;
}
((AudioImporter)assetImporter)
.SetOverrideSampleSettings("Standalone", sampleSettings);
}
}
private bool IsEqualAudioSampleSetting(AudioImporterSampleSettings target, AudioImporterSampleSettings reference)
{
// defaultSampleSettings
if (target.compressionFormat != reference.compressionFormat)
{
return(false);
}
if (target.loadType != reference.loadType)
{
return(false);
}
if (target.quality != reference.quality)
{
return(false);
}
if (target.sampleRateOverride != reference.sampleRateOverride)
{
return(false);
}
if (target.sampleRateSetting != reference.sampleRateSetting)
{
return(false);
}
return(true);
}
/// <summary>
/// 更改导入音频的格式
/// </summary>
void OnPreprocessAudio()
{
if (IsAssetProcessed)
{
return;
}
IsAssetProcessed = true;
AudioImporter audioImporter = (AudioImporter)assetImporter;
if (audioImporter == null)
{
return;
}
AudioImporterSampleSettings sampleSetting = new AudioImporterSampleSettings();
sampleSetting.loadType = AudioClipLoadType.CompressedInMemory;
sampleSetting.compressionFormat = AudioCompressionFormat.Vorbis;
sampleSetting.quality = 0.01f;//1为100
//这种情况下可以改变默认Defalut下面的格式
audioImporter.defaultSampleSettings = sampleSetting;
//这种情况下只会更改PC/IOS/Android下面的格式
bool successfullOverride = audioImporter.SetOverrideSampleSettings("PC", sampleSetting);
//Debug.Log(successfullOverride);
}
void OnPreprocessAudio()
{
if (isInFolder(FxFolderName))
{
//SoundFX configuration
AudioImporter audioImporter = (AudioImporter)assetImporter;
audioImporter.forceToMono = true;
AudioImporterSampleSettings settings = new AudioImporterSampleSettings();
settings.loadType = AudioClipLoadType.DecompressOnLoad;
settings.compressionFormat = AudioCompressionFormat.PCM;
settings.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
audioImporter.defaultSampleSettings = settings;
}
else if (isInFolder(MusicFolderName))
{
//Music configuration
AudioImporter audioImporter = (AudioImporter)assetImporter;
audioImporter.forceToMono = true;
AudioImporterSampleSettings settings = new AudioImporterSampleSettings();
settings.loadType = AudioClipLoadType.CompressedInMemory;
settings.compressionFormat = AudioCompressionFormat.Vorbis;
settings.quality = 100.0f;
settings.sampleRateSetting = AudioSampleRateSetting.PreserveSampleRate;
audioImporter.defaultSampleSettings = settings;
}
}
/// <summary>
/// This function is for post processing project imported audio assets.
/// </summary>
/// <param name="importConfiguration">Takes in the import configuration asset.</param>
/// <param name="assetPostprocessor">Takes in the asset postprocessor class.</param>
public static void ProcessAudioAsset(ConfigurationAsset importConfiguration, AssetPostprocessor assetPostprocessor)
{
// Trying to modify the audio importer settings.
try
{
// Getting the audio asset impoprter settings
var audioImporter = assetPostprocessor.assetImporter as AudioImporter;
// Getting the default audio importer sample settings from the new audio imported.
AudioImporterSampleSettings audioConfiguration = audioImporter.defaultSampleSettings;
// Applying the configured audio settings data to the imported audio asset.
audioConfiguration.loadType = importConfiguration.AudioImportConfiguration.LoadType;
audioConfiguration.sampleRateSetting = importConfiguration.AudioImportConfiguration.SampleRate;
audioConfiguration.compressionFormat = importConfiguration.AudioImportConfiguration.CompressionFormat;
// Assigning configured audio importer configurations.
audioImporter.defaultSampleSettings = audioConfiguration;
// Checking for active audio overide platorm option.
bool platformOverideEnabled = importConfiguration.AudioImportConfiguration.AudioOveridePlatormOption != PlatformOption.None;
// Checking if platform settings overide is enabled.
if (platformOverideEnabled)
{
// Overiding platform settings for selected runtime platform.
audioImporter.SetOverrideSampleSettings(importConfiguration.AudioImportConfiguration.AudioOveridePlatormOption.ToString(), audioConfiguration);
}
}
catch (Exception e)
{
// Throwing a new system exception.
Debugger.ThrowException(e);
}
}
void OnPostprocessAudio(AudioClip clip)
{
if (assetPath.StartsWith(music_path))
{
string abName = new DirectoryInfo(Path.GetFileNameWithoutExtension(assetPath)).Name.ToLower();
assetImporter.assetBundleName = "music/" + abName + ".u3d";
AudioImporter audio = assetImporter as AudioImporter;
if (audio != null)
{
AudioImporterSampleSettings audioSettings = new AudioImporterSampleSettings();
audioSettings.loadType = AudioClipLoadType.Streaming;
audioSettings.compressionFormat = AudioCompressionFormat.Vorbis;
audioSettings.quality = 0.1f;
audioSettings.sampleRateSetting = AudioSampleRateSetting.OverrideSampleRate;
audioSettings.sampleRateOverride = 11025;
audio.defaultSampleSettings = audioSettings;
}
}
if (assetPath.StartsWith(sound_path))
{
string abName = new DirectoryInfo(Path.GetFileNameWithoutExtension(assetPath)).Name.ToLower();
assetImporter.assetBundleName = "sounds/" + abName + ".u3d";
}
}
public override void ApplySettings(UnityEditor.AssetImporter assetImporter)
{
AudioImporter importer = assetImporter as AudioImporter;
if (importer == null)
{
return;
}
importer.forceToMono = forceToMono;
if (forceToMono)
{
//importer.normalize = normalize;
}
importer.loadInBackground = loadInBackground;
importer.ambisonic = ambisonic;
importer.preloadAudioData = preloadAudioData;
AudioImporterSampleSettings sampleSettings = importer.defaultSampleSettings;
sampleSettings.loadType = loadType;
sampleSettings.compressionFormat = compressionFormat;
sampleSettings.quality = quality;
sampleSettings.sampleRateSetting = sampleRateSetting;
sampleSettings.sampleRateOverride = (uint)sampleRate;
importer.defaultSampleSettings = sampleSettings;
importer.SetOverrideSampleSettings("Android", sampleSettings);
importer.SetOverrideSampleSettings("iPhone", sampleSettings);
//importer.SaveAndReimport();
}
private void OnPostprocessAudio(AudioClip arg)
{
AudioModifier.modifyAttributes();
var importer = assetImporter as AudioImporter;
if (importer == null)
{
return;
}
AudioImporterSampleSettings sampleSettings = importer.defaultSampleSettings;
sampleSettings.loadType = AudioClipLoadType.Streaming;
sampleSettings.compressionFormat = AudioCompressionFormat.AAC;
importer.defaultSampleSettings = sampleSettings;
Debug.Log(arg);
///throw new NotImplementedException();
}
void OnPreprocessAudio()
{
ImportProperties importProperties = (ImportProperties)AssetDatabase.LoadAssetAtPath("Assets/Prefabs/ImportProperties.prefab", typeof(ImportProperties));
if (importProperties && importProperties.enableCustomImportSetting)
{
AudioImporter audioImporter = assetImporter as AudioImporter;
var a = audioImporter.defaultSampleSettings;
a.compressionFormat = importProperties.audioCompressionFormat;
a.sampleRateSetting = importProperties.audioSampleRateSetting;
a.loadType = importProperties.audioClipLoadType;
audioImporter.defaultSampleSettings = a;
// Override Android Import Settings
if (importProperties.overrideAudioForAndroid)
{
AudioImporterSampleSettings settings = new AudioImporterSampleSettings();
settings.compressionFormat = importProperties.audioCompressionFormatForAndroid;
settings.sampleRateSetting = importProperties.audioSampleRateSettingForAndroid;
settings.loadType = importProperties.audioClipLoadTypeForAndroid;
audioImporter.SetOverrideSampleSettings("Android", settings);
}
}
}
static void SetLongAudio(AudioImporter ai, AudioImporterSampleSettings ais)
{
ai.loadInBackground = true;
ais.loadType = LongAudio;
ai.defaultSampleSettings = ais;
ai.SetOverrideSampleSettings(Standalone, ais);
}
/// <summary>
/// 复制音频导入器
/// </summary>
public static void CopyAudioImporter(AudioImporter targetImporter, AudioImporter templateImporter)
{
// 通用属性
targetImporter.forceToMono = templateImporter.forceToMono;
targetImporter.loadInBackground = templateImporter.loadInBackground;
targetImporter.ambisonic = templateImporter.ambisonic;
targetImporter.defaultSampleSettings = templateImporter.defaultSampleSettings;
// 注意：Normalize没有暴露的接口
var templateObject = new SerializedObject(templateImporter);
var templateProperty = templateObject.FindProperty("m_Normalize");
var targetObject = new SerializedObject(targetImporter);
var targetProperty = targetObject.FindProperty("m_Normalize");
targetProperty.boolValue = templateProperty.boolValue;
targetObject.ApplyModifiedProperties();
// 平台设置
AudioImporterSampleSettings sampleSettingsPC = templateImporter.GetOverrideSampleSettings("Standalone");
AudioImporterSampleSettings sampleSettingsIOS = templateImporter.GetOverrideSampleSettings("iOS");
AudioImporterSampleSettings sampleSettingsAndroid = templateImporter.GetOverrideSampleSettings("Android");
targetImporter.SetOverrideSampleSettings("Standalone", sampleSettingsPC);
targetImporter.SetOverrideSampleSettings("iOS", sampleSettingsIOS);
targetImporter.SetOverrideSampleSettings("Android", sampleSettingsAndroid);
}
/*
* .AIFF 适用于较短的音乐文件可用作游戏打斗音效
* .WAV 适用于较短的音乐文件可用作游戏打斗音效
* .MP3 适用于较长的音乐文件可用作游戏背景音乐
* .OGG 适用于较长的音乐文件可用作游戏背景音乐
*
* 音频格式(Audio Format)： 在运行时被应用到声音上的特定格式。
*
* 原生的(Native):较大文件尺寸，质量较高。最适用于很短的音效。
* 压缩的(Compressed):较小文件尺寸，质量较低/不稳定。最适用于中等长度音效与音乐。
* 三维声音(3D Sound)：如果启用，音乐将在3D空间中播放。
*
* 强制单声道(Force to mono)：如果启用，该音频剪辑将向下混合到单通道声音。
*
* 加载类型(Load Type)： 运行时Unity加载音频的方法。
*
* 加载时解压缩(Decompress on load): 加载后解压缩声音。使用于较小的压缩声音，以避免运行时解压缩的性能开销。(将使用比在它们在内存中压缩的多10倍或更多内存，因此大文件不要使用这个。)
* 在内存中压缩(Compressed in memory): 保持声音在内存中（压缩的）在播放时解压缩。这有轻微的性能开销（尤其是OGG / Vorbis格式的压缩文件），因此大文件使用这个。
* 从磁盘流(Stream from disc): 直接从磁盘流读取音频数据。这只使用了原始声音占内存大小的很小一部分。使用这个用于很长的音乐。取决于硬件，一般建议1-2线程同时流。
* 压缩(Compression)： 压缩量应用于压缩的剪辑,保持在一个足够小的尺寸，以满足您的文件大小/分配需要。可以拖动滑条来调整大小，播放声音来判断音质，滑动条后面可以看到文件大小的统计。
*
* 硬件解码(Hardware Decoding)：（仅iOS）用于iOS设备压缩的音频。使用苹果的硬件解码来减少CPU的密集解压缩。（同一时间只能有一个硬件音频流解压缩，包括背景的iPod音频。）
*
* 无缝循环(Gapless looping)：（仅Android/iOS）压缩一个完美的循环音频源文件（非压缩的PCM格式）保持循环。标准的MPEG编码器插入silence循环点，播放时有小的"click" 或 "pop" Unity为你顺畅处理这个问题。
*
*/
#region 音频处理
public void OnPreprocessAudio()
{
AudioImporter importer = assetImporter as AudioImporter;
if (importer != null)
{
if (IsFirstImport(importer))
{
AudioImporterSampleSettings AudioSetting = new AudioImporterSampleSettings();
// //加载方式选择
AudioSetting.loadType = AudioClipLoadType.CompressedInMemory;
// //压缩方式选择
AudioSetting.compressionFormat = AudioCompressionFormat.Vorbis;
// //设置播放质量
AudioSetting.quality = 0.1f;
// //优化采样率
AudioSetting.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
// //开启单声道
importer.forceToMono = true;
importer.loadInBackground = false;
importer.preloadAudioData = true;
importer.defaultSampleSettings = AudioSetting;
Debug.Log("音频导前预处理");
}
}
}
public static void ApplyRulesToAudioClip(AudioImporter audioClipImporter,
AudioClipImportRule.AudioClipImportData data)
{
if (null == audioClipImporter)
{
return;
}
audioClipImporter.forceToMono = data.IsForceToMono;
audioClipImporter.loadInBackground = data.IsLoadInBackground;
audioClipImporter.ambisonic = data.IsAmbisonic;
audioClipImporter.preloadAudioData = data.IsPreloadAudioClip;
AudioImporterSampleSettings settingAndroid = audioClipImporter.GetOverrideSampleSettings("Android");
settingAndroid.compressionFormat = data.AndroidCompressionFormat;
settingAndroid.loadType = data.AndroidAudioClipLoadType;
settingAndroid.quality = data.Quality;
audioClipImporter.SetOverrideSampleSettings("Android", settingAndroid);
AudioImporterSampleSettings iPhoneAndroid = audioClipImporter.GetOverrideSampleSettings("iOS");
iPhoneAndroid.compressionFormat = data.AndroidCompressionFormat;
iPhoneAndroid.loadType = data.AndroidAudioClipLoadType;
iPhoneAndroid.quality = data.Quality;
audioClipImporter.SetOverrideSampleSettings("iOS", iPhoneAndroid);
audioClipImporter.SaveAndReimport();
}
//static string AudioInfoBegin = "[AUD-";
//static string AudioInfoEnd = "-AUD]";
//private void OnPostprocessAudio(AudioClip clip)
//{
// string AudioInfo;
// float length;
// string AudioInfoOld;
// AudioInfo = ConvertAudioInfo(clip.length);
// if (GetAudioInfo(assetImporter, out length))
// {
// AudioInfoOld = ConvertAudioInfo(length);
// if (!AudioInfoOld.Equals(AudioInfo))
// {
// assetImporter.userData = assetImporter.userData.Replace(AudioInfoOld, string.Empty);
// }
// }
// if (!assetImporter.userData.Contains(AudioInfo))
// {
// assetImporter.userData += AudioInfo;
// }
//}
//private static string ConvertAudioInfo(float length)
//{
// return AudioInfoBegin + length.ToString("F3") + AudioInfoEnd;
//}
//private static bool GetAudioInfo(AssetImporter assetImporter, out float length)
//{
// length = 0;
// string filePatch = AssetBundleManagerEditor.ConverRelativePatchToObslotePatch(assetImporter.assetPath);
// filePatch += ".meta";
// if (!File.Exists(filePatch))
// {
// return false;
// }
// string userData = assetImporter.userData;
// //if (!userData.Contains(TextureInfoBegin))
// //{
// //string text = System.IO.File.ReadAllText(filePatch);
// //List<string> alltext = new List<string>();
// //alltext.AddRange(text.Split('\n'));
// //string strAbVar = " userData: ";
// //for (int i = alltext.Count - 1; i >= 0; i--)
// //{
// // string s = alltext[i];
// // if (s.Contains(strAbVar))
// // {
// // userData = s.Replace(strAbVar, string.Empty);
// // }
// //}
// //}
// if (!userData.Contains(AudioInfoBegin))
// {
// return false;
// }
// int begin = userData.IndexOf(AudioInfoBegin);
// int end = userData.IndexOf(AudioInfoEnd);
// string reslut = userData.Substring(begin, end - begin);
// reslut = reslut.Replace(AudioInfoBegin, string.Empty);
// reslut = reslut.Replace(AudioInfoEnd, string.Empty);
// return float.TryParse(reslut, out length); ;
//}
public void OnPostprocessAudio(AudioClip clip)
{
AudioImporter imp = assetImporter as AudioImporter;
string asPatch = imp.assetPath;
AudioImporterSampleSettings ass = imp.defaultSampleSettings;
ass.quality = 0.8f;
float length = clip.length;
if (length < 2.0f)
{
ass.compressionFormat = AudioCompressionFormat.PCM;
ass.loadType = AudioClipLoadType.DecompressOnLoad;
}
else if (length < 5.0f)
{
ass.compressionFormat = AudioCompressionFormat.ADPCM;
ass.loadType = AudioClipLoadType.DecompressOnLoad;
}
else
{
ass.compressionFormat = AudioCompressionFormat.Vorbis;
ass.loadType = AudioClipLoadType.Streaming;
}
imp.defaultSampleSettings = ass;
}
static void OnPreprocessSoundClip(string assetPath, AudioImporter importer)
{
importer.loadInBackground = false;
var standalone = new AudioImporterSampleSettings();
standalone.quality = 0.7f;
standalone.loadType = AudioClipLoadType.DecompressOnLoad;
standalone.compressionFormat = AudioCompressionFormat.PCM;
standalone.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
importer.SetOverrideSampleSettings("Standalone", standalone);
var iOS = new AudioImporterSampleSettings();
iOS.quality = 0.7f;
iOS.loadType = AudioClipLoadType.DecompressOnLoad;
iOS.compressionFormat = AudioCompressionFormat.MP3;
iOS.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
importer.SetOverrideSampleSettings("iOS", iOS);
var android = new AudioImporterSampleSettings();
android.quality = 0.7f;
android.loadType = AudioClipLoadType.DecompressOnLoad;
android.compressionFormat = AudioCompressionFormat.ADPCM;
android.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
importer.SetOverrideSampleSettings("Android", android);
}
void OnPostprocessAudio(AudioClip clip)
{
AudioImporter importer = (AudioImporter)assetImporter;
importer.forceToMono = true;
AudioImporterSampleSettings defSetting = importer.defaultSampleSettings;
if (importer.assetPath.Contains("Stroy") || importer.assetPath.Contains("Voice"))
{
importer.preloadAudioData = false;
}
if (clip.length > 10)
{
defSetting.loadType = AudioClipLoadType.CompressedInMemory;
importer.defaultSampleSettings = defSetting;
AudioImporterSampleSettings androidSetting = importer.GetOverrideSampleSettings("Android");
androidSetting.loadType = AudioClipLoadType.Streaming;
importer.SetOverrideSampleSettings("Android", androidSetting);
}
else
{
defSetting.loadType = AudioClipLoadType.DecompressOnLoad;
defSetting.compressionFormat = AudioCompressionFormat.ADPCM;
importer.defaultSampleSettings = defSetting;
}
}
private void ReportAudio(StringBuilder sb, AudioImporter importer)
{
/// common
sb.Append("{");
AssetsReporterUtils.AddJsonObject(sb, "path", importer.assetPath).Append(",");
AssetsReporterUtils.AddJsonObject(sb, "forceToMono", importer.forceToMono).Append(",");
AssetsReporterUtils.AddJsonObject(sb, "loadInBackground", importer.loadInBackground).Append(",");
AssetsReporterUtils.AddJsonObject(sb, "preloadAudioData", importer.preloadAudioData).Append(",");
// platform setting
AudioImporterSampleSettings setting = importer.defaultSampleSettings;
if (!string.IsNullOrEmpty(platform) && importer.ContainsSampleSettingsOverride(platform))
{
setting = importer.GetOverrideSampleSettings(platform);
}
AssetsReporterUtils.AddJsonObject(sb, "loadType", setting.loadType.ToString()).Append(",");
AssetsReporterUtils.AddJsonObject(sb, "compressionFormat", setting.compressionFormat.ToString()).Append(",");
AssetsReporterUtils.AddJsonObject(sb, "sampleRateSetting", setting.sampleRateSetting.ToString()).Append(",");
AssetsReporterUtils.AddJsonObject(sb, "sampleRateOverride", setting.sampleRateOverride.ToString());
sb.Append("}");
AssetsReporterUtils.AddCountDictionary(this.loadTypeSet, setting.loadType);
AssetsReporterUtils.AddCountDictionary(this.ratingSet, setting.sampleRateOverride);
AssetsReporterUtils.AddCountDictionary(this.compressSet, setting.compressionFormat);
}
static void OnPreprocessMusicClip(string assetPath, AudioImporter importer)
{
importer.loadInBackground = true;
var standalone = new AudioImporterSampleSettings();
standalone.quality = 0.7f;
standalone.loadType = AudioClipLoadType.Streaming;
standalone.compressionFormat = AudioCompressionFormat.Vorbis;
standalone.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
importer.SetOverrideSampleSettings("Standalone", standalone);
var iOS = new AudioImporterSampleSettings();
iOS.quality = 0.7f;
iOS.loadType = AudioClipLoadType.Streaming;
iOS.compressionFormat = AudioCompressionFormat.MP3;
iOS.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
importer.SetOverrideSampleSettings("iOS", iOS);
var android = new AudioImporterSampleSettings();
android.quality = 0.7f;
android.loadType = AudioClipLoadType.Streaming;
android.compressionFormat = AudioCompressionFormat.Vorbis;
android.sampleRateSetting = AudioSampleRateSetting.OptimizeSampleRate;
importer.SetOverrideSampleSettings("Android", android);
}
private void OnPreprocessAsset()
{
AudioImporter ai = assetImporter as AudioImporter;
if (ai == null)
{
return;
}
AudioImporterSampleSettings set = new AudioImporterSampleSettings();
ai.loadInBackground = false;
ai.preloadAudioData = true;
ai.ambisonic = false;
set.loadType = AudioClipLoadType.CompressedInMemory;
set.sampleRateOverride = 44100;
set.compressionFormat = AudioCompressionFormat.Vorbis;
if (ai.assetPath.Contains("BGM"))
{
set.quality = 0.8f;
ai.forceToMono = false;
}
else
{
set.quality = 0.6f;
ai.forceToMono = true;
}
ai.SetOverrideSampleSettings("PC", set);
ai.SetOverrideSampleSettings("iOS", set);
ai.SetOverrideSampleSettings("Android", set);
}
public void AudioMethod()
{
#if UNITY_EDITOR
var allModel = Path.Combine(Application.dataPath, "Resources/sound");
//var import = ModelImporter.GetAtPath("Assets/Resources/sound") as ModelImporter;
Debug.Log("allModel " + allModel);
var resDir = new DirectoryInfo(allModel);
var fileInfo = resDir.GetFiles("*.wav", SearchOption.AllDirectories);
AssetDatabase.StartAssetEditing();
foreach (FileInfo file in fileInfo)
{
Debug.Log("Directory name " + file.FullName);
var ass = file.FullName.Replace(Application.dataPath, "Assets");
var import = AudioImporter.GetAtPath(ass) as AudioImporter;
//Debug.Log("import "+import);
//import.format = AudioImporterFormat.Compressed;
var defSamp = new AudioImporterSampleSettings()
{
compressionFormat = AudioCompressionFormat.Vorbis,
loadType = AudioClipLoadType.CompressedInMemory,
quality = 1,
};
import.defaultSampleSettings = defSamp;
//import.defaultSampleSettings.compressionFormat = AudioCompressionFormat.Vorbis;
//import.defaultSampleSettings.loadType = AudioClipLoadType.CompressedInMemory;
//import.compressionBitrate = 32000;
//Debug.Log("import "+import.compressionBitrate);
AssetDatabase.WriteImportSettingsIfDirty(ass);
}
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh();
#endif
}
private void OnPreprocessAudio()
{
AudioImporter audioImporter = (AudioImporter)assetImporter;
AudioImporterSampleSettings sampleSettings = audioImporter.defaultSampleSettings;
FileInfo f = new FileInfo(assetPath);
long size = f.Length / 1024; // size in kb
if (size < MIN_SIZE_TRESHOLD)
{
sampleSettings.loadType = AudioClipLoadType.DecompressOnLoad;
sampleSettings.compressionFormat = AudioCompressionFormat.ADPCM;
}
else if (size > MIN_SIZE_TRESHOLD)
{
if (size < MUSIC_SIZE_TRESHOLD)
{
// if file size is less than 5mb -> sound effect
sampleSettings.loadType = AudioClipLoadType.CompressedInMemory;
sampleSettings.compressionFormat = AudioCompressionFormat.ADPCM;
}
else
{
// if file size is greater than 5mb -> background music
sampleSettings.loadType = AudioClipLoadType.Streaming;
sampleSettings.compressionFormat = AudioCompressionFormat.Vorbis;
sampleSettings.quality = 0.5f;
}
}
audioImporter.defaultSampleSettings = sampleSettings;
}
private void ApplyClipChanges(AudioInformation info, bool writeChanges)
{
Selection.objects = new Object[] { }; // unselect to get "Apply" to work automatically.
// ReSharper disable once AccessToStaticMemberViaDerivedType
var importer = (AudioImporter)AudioImporter.GetAtPath(info.FullPath);
AudioImporterSampleSettings settings = importer.defaultSampleSettings;
importer.forceToMono = info.ForceMono;
importer.loadInBackground = info.LoadBG;
importer.preloadAudioData = info.Preload;
settings.loadType = info.LoadType;
settings.compressionFormat = info.CompressionFormat;
if (settings.compressionFormat == AudioCompressionFormat.Vorbis)
{
settings.quality = info.Quality;
}
settings.sampleRateSetting = info.SampleRateSetting;
if (settings.sampleRateSetting == AudioSampleRateSetting.OverrideSampleRate)
{
settings.sampleRateOverride = (uint)info.SampleRateOverride;
}
importer.defaultSampleSettings = settings;
AssetDatabase.ImportAsset(info.FullPath, ImportAssetOptions.ForceUpdate);
info.HasChanged = true;
if (writeChanges)
{
WriteFile(_clipList);
}
}
public AudioPlatformNorm GetPlatformSetting(AudioImporterSampleSettings platformSetting, string platform,
AudioClipLoadType audioClipLoadType_Short, AudioCompressionFormat compressionFormat_Short,
AudioClipLoadType audioClipLoadType_Long, AudioCompressionFormat compressionFormat_Long)
{
AudioPlatformNorm apn = new AudioPlatformNorm()
{
platform = platform,
setting = platformSetting,
};
if (autioType == "Long")
{
apn.recommendloadType = audioClipLoadType_Long;
apn.recommendCompressionFormat = compressionFormat_Long;
if (clip.loadType != audioClipLoadType_Long)
{
apn.loadTypeLevel = 2;
errorNum++;
}
else
{
apn.loadTypeLevel = 0;
}
if (audioImporter.defaultSampleSettings.compressionFormat != compressionFormat_Long)
{
apn.compressionFormatLevel = 2;
errorNum++;
}
else
{
apn.compressionFormatLevel = 0;
}
}
else
{
apn.recommendloadType = audioClipLoadType_Short;
apn.recommendCompressionFormat = compressionFormat_Short;
if (clip.loadType != audioClipLoadType_Short)
{
apn.loadTypeLevel = 2;
errorNum++;
}
else
{
apn.loadTypeLevel = 0;
}
if (audioImporter.defaultSampleSettings.compressionFormat != compressionFormat_Short)
{
apn.compressionFormatLevel = 2;
errorNum++;
}
else
{
apn.compressionFormatLevel = 0;
}
}
return(apn);
}
private static string GetQualityString(AudioImporterSampleSettings importer)
{
var format = importer.compressionFormat;
return(format == AudioCompressionFormat.Vorbis || format == AudioCompressionFormat.AAC
? "100"
: $"{((int)importer.quality * 100)}");
}
/// <summary>
/// 更改音效设置
/// </summary>
/// <param name="importer"></param>
/// <param name="platform"></param>
/// <param name="loadType"></param>
public static void SetAudioSettingExt(this AudioImporter importer, string platform, AudioClipLoadType loadType, AudioCompressionFormat format, float quality = 1)
{
AudioImporterSampleSettings settings = importer.GetOverrideSampleSettings(platform);
settings.loadType = loadType;
settings.compressionFormat = format;
settings.quality = quality;
importer.SetOverrideSampleSettings(platform, settings);
}
/// <summary>
/// 设置音频文件导入后的推荐参数
/// </summary>
/// <param name="ac"></param>
private void OnPostprocessAudio(AudioClip audioClip)
{
if (assetPath.StartsWith("Assets/Arts/Sounds/"))
{
AudioImporter audioImporter = assetImporter as AudioImporter;
AudioImporterSampleSettings sampleSettings = audioImporter.defaultSampleSettings;
sampleSettings.loadType = AudioClipLoadType.Streaming;
audioImporter.defaultSampleSettings = sampleSettings;
}
}
static void ChangeAudioImportSettings(string path)
{
AudioImporter imp = AssetImporter.GetAtPath(path) as AudioImporter;
imp.loadInBackground = true;
imp.preloadAudioData = false;
AudioImporterSampleSettings settings = imp.defaultSampleSettings;
settings.compressionFormat = AudioCompressionFormat.Vorbis;
imp.defaultSampleSettings = settings;
imp.SaveAndReimport();
}
