/// <summary>
        /// Creates wav file in temp directory
        /// </summary>
        /// <param name="ws"></param>
        /// <returns></returns>
        public static string CreateWave(this WwiseStream ws)
        {
            string basePath = WwiseStreamHelper.GetATempSoundPath();
            string wavPath  = basePath + ".wav";

            if (ws.CreateWaveStream() is MemoryStream dataStream)
            {
                File.WriteAllBytes(wavPath, dataStream.ToArray());
            }
            return(wavPath);
        }
        /// <summary>
        /// Creates wav stream from this WwiseStream
        /// </summary>
        /// <param name="afcPath"></param>
        /// <returns></returns>
        public static MemoryStream CreateWaveStream(this WwiseStream ws)
        {
            string basePath = WwiseStreamHelper.GetATempSoundPath();
            string wemPath  = basePath + ".wem";

            if (ws.ExtractRawFromSourceToFile(wemPath))
            {
                return(ISBankEntry.ConvertAudioToWave(wemPath));
            }

            return(null);
        }
 public static bool ExtractRawFromSourceToFile(this WwiseStream ws, string outputFile)
 {
     if (ws.IsPCCStored)
     {
         if (ws.EmbeddedData is null || ws.EmbeddedData.Length == 0)
         {
             return(false);
         }
         if (File.Exists(outputFile))
         {
             File.Delete(outputFile);
         }
         File.WriteAllBytes(outputFile, ws.EmbeddedData);
         return(true);
     }
     return(WwiseStreamHelper.ExtractRawFromSourceToFile(outputFile, ws.GetPathToAFC(), ws.DataSize, ws.DataOffset));
 }
        private static void ImportWwiseOgg(this WwiseStream ws, string pathafc, Stream wwiseOggStream)
        {
            if ((!ws.IsPCCStored && !File.Exists(pathafc)) || wwiseOggStream == null)
            {
                return;
            }
            //Convert wwiseoggstream
            MemoryStream convertedStream = WwiseStreamHelper.ConvertWwiseOggToME3Ogg(wwiseOggStream);

            byte[] newWavfile = convertedStream.ToArray();

            if (ws.IsPCCStored)
            {
                ws.EmbeddedData = newWavfile;
                //DataSize and DataOffset are automatically calculated during serialization
                //when EmbeddedData != null
                return;
            }


            //Open AFC
            FileStream fs     = new FileStream(pathafc, FileMode.Open, FileAccess.Read);
            var        Header = new byte[94];

            //Seek to data we are replacing and read header
            fs.Seek(ws.DataOffset, SeekOrigin.Begin);
            fs.Read(Header, 0, 94);
            fs.Close();


            //append new wav
            fs = new FileStream(pathafc, FileMode.Append, FileAccess.Write, FileShare.Write);
            int newWavDataOffset = (int)fs.Length;
            int newWavSize       = newWavfile.Length;

            fs.Write(newWavfile, 0, newWavSize);
            fs.Close();

            ws.DataSize     = newWavSize;
            ws.DataOffset   = newWavDataOffset;
            ws.EmbeddedData = null;
        }