/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Stream to access in-memory data to be parsed</param>
/// <param name="mimeType">Mime-type of the stream to process</param>
/// <param name="readEmbeddedPictures">Embedded pictures will be read if true; ignored if false</param>
/// <param name="readAllMetaFrames">All metadata frames (including unmapped ones) will be read if true; ignored if false</param>
/// <param name="writeProgress">Object to use to signal writing progress (optional)</param>
public AudioFileIO(Stream stream, String mimeType, bool readEmbeddedPictures, bool readAllMetaFrames = false, IProgress <float> writeProgress = null)
{
byte alternate = 0;
bool found = false;
audioData = AudioDataIOFactory.GetInstance().GetFromMimeType(mimeType, "In-memory", alternate);
audioManager = new AudioDataManager(audioData, stream, writeProgress);
this.writeProgress = writeProgress;
found = audioManager.ReadFromFile(readEmbeddedPictures, readAllMetaFrames);
while (!found && alternate < AudioDataIOFactory.MAX_ALTERNATES)
{
alternate++;
audioData = AudioDataIOFactory.GetInstance().GetFromMimeType(mimeType, "In-memory", alternate);
audioManager = new AudioDataManager(audioData, stream, writeProgress);
found = audioManager.ReadFromFile(readEmbeddedPictures, readAllMetaFrames);
}
metaData = MetaDataIOFactory.GetInstance().GetMetaReader(audioManager);
if (metaData is DummyTag && (0 == audioManager.getAvailableMetas().Count))
{
LogDelegator.GetLogDelegate()(Log.LV_WARNING, "Could not find any metadata");
}
}
private void testGenericAudio(
string resource,
int duration,
int bitrate,
int samplerate,
bool isVbr,
int codecFamily,
ChannelsArrangement channelsArrangement,
string formatName,
int alternate = 0)
{
ConsoleLogger log = new ConsoleLogger();
string theResource = TestUtils.GetResourceLocationRoot() + resource;
IAudioDataIO theReader = AudioDataIOFactory.GetInstance().GetFromPath(theResource, alternate);
Assert.IsNotInstanceOfType(theReader, typeof(ATL.AudioData.IO.DummyReader));
AudioDataManager manager = new AudioDataManager(theReader);
manager.ReadFromFile();
Assert.AreEqual(duration, (int)Math.Round(theReader.Duration));
Assert.AreEqual(bitrate, (int)Math.Round(theReader.BitRate));
Assert.AreEqual(samplerate, theReader.SampleRate);
Assert.AreEqual(theReader.IsVBR, isVbr);
Assert.AreEqual(codecFamily, theReader.CodecFamily);
Assert.AreEqual(channelsArrangement, theReader.ChannelsArrangement);
Assert.AreEqual(formatName, theReader.AudioFormat.Name);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Stream to access in-memory data to be parsed</param>
/// <param name="mimeType">the file's mime type.</param>
/// <param name="readEmbeddedPictures">Embedded pictures will be read if true; ignored if false</param>
/// <param name="readAllMetaFrames">All metadata frames (including unmapped ones) will be read if true; ignored if false</param>
public AudioFileIo(Stream stream, String mimeType, Boolean readEmbeddedPictures, Boolean readAllMetaFrames = false)
{
Byte alternate = 0;
var found = false;
_audioData = AudioDataIoFactory.GetInstance().GetFromMimeType(mimeType, "In-memory", alternate);
_audioManager = new AudioDataManager(_audioData, stream);
found = _audioManager.ReadFromFile(readEmbeddedPictures, readAllMetaFrames);
while (!found && alternate < AudioDataIoFactory.MaxAlternates)
{
alternate++;
_audioData = AudioDataIoFactory.GetInstance().GetFromMimeType(mimeType, "In-memory", alternate);
_audioManager = new AudioDataManager(_audioData, stream);
found = _audioManager.ReadFromFile(readEmbeddedPictures, readAllMetaFrames);
}
_metaData = MetaDataIOFactory.GetInstance().GetMetaReader(_audioManager);
if (_metaData is DummyTag && (0 == _audioManager.getAvailableMetas().Count))
{
LogDelegator.GetLogDelegate()(Log.LV_WARNING, "Could not find any metadata");
}
}
// ------------------------------------------------------------------------------------------
/// <summary>
/// Constructor
/// </summary>
/// <param name="path">Path of the file to be parsed</param>
public AudioFileIO(string path, bool readEmbeddedPictures, bool readAllMetaFrames = false)
{
byte alternate = 0;
bool found = false;
thePath = path;
audioData = AudioDataIOFactory.GetInstance().GetDataReader(path, alternate);
audioManager = new AudioDataManager(audioData);
found = audioManager.ReadFromFile(readEmbeddedPictures, readAllMetaFrames);
while (!found && alternate < AudioDataIOFactory.MAX_ALTERNATES)
{
alternate++;
audioData = AudioDataIOFactory.GetInstance().GetDataReader(path, alternate);
audioManager = new AudioDataManager(audioData);
found = audioManager.ReadFromFile(readEmbeddedPictures, readAllMetaFrames);
}
metaData = MetaDataIOFactory.GetInstance().GetMetaReader(audioManager);
if (metaData is DummyTag && (0 == audioManager.getAvailableMetas().Count))
{
LogDelegator.GetLogDelegate()(Log.LV_WARNING, "Could not find any metadata");
}
}
public AudioDataManager(IAudioDataIO audioDataReader)
{
this.audioDataIO = audioDataReader;
}
public void Audio_FallbackToDummy()
{
IAudioDataIO theReader = AudioDataIOFactory.GetInstance().GetFromPath(TestUtils.GetResourceLocationRoot() + "MP3/01 - Title Screen.xyz");
Assert.IsInstanceOfType(theReader, typeof(ATL.AudioData.IO.DummyReader));
}
public IAudioDataIO GetFromPath(String path, int alternate = 0)
{
IList <Format> formats = getFormatsFromPath(path);
Format theFormat;
if (formats != null && formats.Count > alternate)
{
theFormat = formats[alternate];
}
else
{
theFormat = UNKNOWN_FORMAT;
}
int formatId = theFormat.ID;
IAudioDataIO theDataReader = null;
switch (formatId)
{
case CID_MP3:
theDataReader = new IO.MPEGaudio(path, theFormat);
break;
case CID_AAC:
theDataReader = new IO.AAC(path, theFormat);
break;
case CID_MP4:
theDataReader = new IO.MP4(path, theFormat);
break;
case CID_WMA:
theDataReader = new IO.WMA(path, theFormat);
break;
case CID_OGG:
theDataReader = new IO.Ogg(path, theFormat);
break;
case CID_FLAC:
theDataReader = new IO.FLAC(path, theFormat);
break;
case CID_MPC:
theDataReader = new IO.MPEGplus(path, theFormat);
break;
case CID_AC3:
theDataReader = new IO.AC3(path, theFormat);
break;
case CID_DSF:
theDataReader = new IO.DSF(path, theFormat);
break;
case CID_DTS:
theDataReader = new IO.DTS(path, theFormat);
break;
case CID_IT:
theDataReader = new IO.IT(path, theFormat);
break;
case CID_MIDI:
theDataReader = new IO.Midi(path, theFormat);
break;
case CID_MOD:
theDataReader = new IO.MOD(path, theFormat);
break;
case CID_APE:
theDataReader = new IO.APE(path, theFormat);
break;
case CID_OFR:
theDataReader = new IO.OptimFrog(path, theFormat);
break;
case CID_WAVPACK:
theDataReader = new IO.WAVPack(path, theFormat);
break;
case CID_WAV:
theDataReader = new IO.WAV(path, theFormat);
break;
case CID_PSF:
theDataReader = new IO.PSF(path, theFormat);
break;
case CID_SPC:
theDataReader = new IO.SPC(path, theFormat);
break;
case CID_TAK:
theDataReader = new IO.TAK(path, theFormat);
break;
case CID_S3M:
theDataReader = new IO.S3M(path, theFormat);
break;
case CID_XM:
theDataReader = new IO.XM(path, theFormat);
break;
case CID_TTA:
theDataReader = new IO.TTA(path, theFormat);
break;
case CID_VQF:
theDataReader = new IO.TwinVQ(path, theFormat);
break;
case CID_AIFF:
theDataReader = new IO.AIFF(path, theFormat);
break;
case CID_VGM:
theDataReader = new IO.VGM(path, theFormat);
break;
case CID_GYM:
theDataReader = new IO.GYM(path, theFormat);
break;
case CID_AA:
theDataReader = new IO.AA(path, theFormat);
break;
default:
theDataReader = new IO.DummyReader(path);
break;
}
return(theDataReader);
}
public IAudioDataIO GetFromMimeType(String mimeType, String path, Int32 alternate = 0)
{
IList <Format> formats;
if (mimeType.StartsWith("."))
{
formats = getFormatsFromPath(mimeType);
}
else
{
formats = getFormatsFromMimeType(mimeType);
}
var formatId = NO_FORMAT;
if (formats != null && formats.Count > alternate)
{
formatId = formats[alternate].ID;
}
IAudioDataIO theDataReader = null;
switch (formatId)
{
case CidMp3:
theDataReader = new IO.MPEGaudio(path);
break;
case CidAac:
theDataReader = new IO.AAC(path);
break;
case CidWma:
theDataReader = new IO.WMA(path);
break;
case CidOgg:
theDataReader = new IO.Ogg(path);
break;
case CidFlac:
theDataReader = new IO.FLAC(path);
break;
case CidMpc:
theDataReader = new IO.MPEGplus(path);
break;
case CidAc3:
theDataReader = new IO.AC3(path);
break;
case CidDsf:
theDataReader = new IO.DSF(path);
break;
case CidDts:
theDataReader = new IO.DTS(path);
break;
case CidIt:
theDataReader = new IO.IT(path);
break;
case CidMidi:
theDataReader = new IO.Midi(path);
break;
case CidMod:
theDataReader = new IO.MOD(path);
break;
case CidApe:
theDataReader = new IO.APE(path);
break;
case CidOfr:
theDataReader = new IO.OptimFrog(path);
break;
case CidWavpack:
theDataReader = new IO.WAVPack(path);
break;
case CidWav:
theDataReader = new IO.WAV(path);
break;
case CidPsf:
theDataReader = new IO.PSF(path);
break;
case CidSpc:
theDataReader = new IO.SPC(path);
break;
case CidTak:
theDataReader = new IO.TAK(path);
break;
case CidS3M:
theDataReader = new IO.S3M(path);
break;
case CidXm:
theDataReader = new IO.XM(path);
break;
case CidTta:
theDataReader = new IO.TTA(path);
break;
case CidVqf:
theDataReader = new IO.TwinVQ(path);
break;
case CidAiff:
theDataReader = new IO.AIFF(path);
break;
case CidVgm:
theDataReader = new IO.VGM(path);
break;
case CidGym:
theDataReader = new IO.GYM(path);
break;
default:
theDataReader = new IO.DummyReader(path);
break;
}
return(theDataReader);
}
public AudioDataManager(IAudioDataIO audioDataReader, IProgress <float> writeProgress = null)
{
this.audioDataIO = audioDataReader;
this.stream = null;
this.writeProgress = writeProgress;
}
public AudioDataManager(IAudioDataIO audioDataReader, Stream stream)
{
audioDataIO = audioDataReader;
this.stream = stream;
}
public AudioDataManager(IAudioDataIO audioDataReader)
{
audioDataIO = audioDataReader;
stream = null;
}
public AudioDataManager(IAudioDataIO audioDataReader)
{
this.audioDataIO = audioDataReader;
this.stream = null;
}
