private Stream SetPlayStream_FromFile_OPEN(
FileStream fileStream,
string filePathOptionalInfo)
{
Stream stream = fileStream;
if (stream != null)
{
stream.Position = 0;
stream.Seek(0, SeekOrigin.Begin);
uint dataLength;
AudioLibPCMFormat format = AudioLibPCMFormat.RiffHeaderParse(stream, out dataLength);
PcmFormat = new PCMFormatInfo(format);
dataLength = (uint)(stream.Length - stream.Position);
stream = new SubStream(stream, stream.Position, dataLength, filePathOptionalInfo);
DebugFix.Assert(dataLength == stream.Length);
DataLength = stream.Length;
EndOffsetOfPlayStream = DataLength;
}
return(stream);
}
/// <summary>
/// Replaces with audio from a RIFF Wave file of a given duration at a given replace point
/// </summary>
/// <param name="riffWaveStream">The RIFF Wave file</param>
/// <param name="replacePoint">The given replace point</param>
/// <param name="duration">The duration of the audio to replace</param>
public void ReplacePcmData_RiffHeader(Stream riffWaveStream, Time replacePoint, Time duration)
{
if (OriginalRelativePath != null && DataProvider != null)
{
throw new NotImplementedException();
}
uint dataLength;
AudioLibPCMFormat format = AudioLibPCMFormat.RiffHeaderParse(riffWaveStream, out dataLength);
if (!format.IsCompatibleWith(PCMFormat.Data))
{
throw new exception.InvalidDataFormatException(
String.Format("RIFF WAV file has incompatible PCM format"));
}
Time fileDuration = new Time(format.ConvertBytesToTime(dataLength));
if (fileDuration.IsLessThan(duration))
{
throw new exception.MethodParameterIsOutOfBoundsException(String.Format(
"Can not insert {0} of audio from RIFF Wave file since the file's duration is only {1}",
duration, fileDuration));
}
ReplacePcmData(riffWaveStream, replacePoint, duration);
}
private AudioLibPCMFormat GetInfo(string name, out uint dataLength)
{
FileStream fs = new FileStream(GetPath(name), FileMode.Open, FileAccess.Read, FileShare.Read);
try
{
return(AudioLibPCMFormat.RiffHeaderParse(fs, out dataLength));
}
finally
{
fs.Close();
}
}
/// <summary>
/// Appends audio data from a RIFF Wave file
/// </summary>
/// <param name="riffWaveStream">The RIFF Wave file</param>
public void AppendPcmData_RiffHeader(Stream riffWaveStream)
{
if (OriginalRelativePath != null && DataProvider != null)
{
throw new NotImplementedException();
}
uint dataLength;
AudioLibPCMFormat format = AudioLibPCMFormat.RiffHeaderParse(riffWaveStream, out dataLength);
if (dataLength <= 0)
{
dataLength = (uint)(riffWaveStream.Length - riffWaveStream.Position);
}
if (!format.IsCompatibleWith(PCMFormat.Data))
{
throw new exception.InvalidDataFormatException(
String.Format("RIFF WAV file has incompatible PCM format"));
}
AppendPcmData(riffWaveStream, new Time(format.ConvertBytesToTime(dataLength)));
}
private void diagramXmlParseBody_(XmlNode diagramElementNode, string xmlFilePath, TreeNode treeNode, int objectIndex)
{
string diagramElementName = diagramElementNode.Name;
AlternateContent altContent = treeNode.Presentation.AlternateContentFactory.CreateAlternateContent();
AlternateContentAddCommand cmd_AltContent =
treeNode.Presentation.CommandFactory.CreateAlternateContentAddCommand(treeNode, altContent);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent);
Metadata diagramElementName_Metadata = treeNode.Presentation.MetadataFactory.CreateMetadata();
diagramElementName_Metadata.NameContentAttribute = new MetadataAttribute();
diagramElementName_Metadata.NameContentAttribute.Name = DiagramContentModelHelper.DiagramElementName;
diagramElementName_Metadata.NameContentAttribute.NamespaceUri = null;
diagramElementName_Metadata.NameContentAttribute.Value = diagramElementName;
AlternateContentMetadataAddCommand cmd_AltContent_diagramElementName_Metadata =
treeNode.Presentation.CommandFactory.CreateAlternateContentMetadataAddCommand(
treeNode,
null,
altContent,
diagramElementName_Metadata,
null
);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_diagramElementName_Metadata);
if (diagramElementNode.Attributes != null)
{
for (int i = 0; i < diagramElementNode.Attributes.Count; i++)
{
XmlAttribute attribute = diagramElementNode.Attributes[i];
if (attribute.Name.StartsWith(XmlReaderWriterHelper.NS_PREFIX_XMLNS + ":"))
{
//
}
else if (attribute.Name == XmlReaderWriterHelper.NS_PREFIX_XMLNS)
{
//
}
else if (attribute.Name == DiagramContentModelHelper.TOBI_Audio)
{
string fullPath = null;
if (FileDataProvider.isHTTPFile(attribute.Value))
{
fullPath = FileDataProvider.EnsureLocalFilePathDownloadTempDirectory(attribute.Value);
}
else
{
fullPath = Path.Combine(Path.GetDirectoryName(xmlFilePath), attribute.Value);
}
if (fullPath != null && File.Exists(fullPath))
{
string extension = Path.GetExtension(fullPath);
bool isWav = extension.Equals(DataProviderFactory.AUDIO_WAV_EXTENSION, StringComparison.OrdinalIgnoreCase);
AudioLibPCMFormat wavFormat = null;
if (isWav)
{
Stream fileStream = File.Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
try
{
uint dataLength;
wavFormat = AudioLibPCMFormat.RiffHeaderParse(fileStream, out dataLength);
}
finally
{
fileStream.Close();
}
}
string originalFilePath = null;
DebugFix.Assert(treeNode.Presentation.MediaDataManager.EnforceSinglePCMFormat);
bool wavNeedsConversion = false;
if (wavFormat != null)
{
wavNeedsConversion = !wavFormat.IsCompatibleWith(treeNode.Presentation.MediaDataManager.DefaultPCMFormat.Data);
}
if (!isWav || wavNeedsConversion)
{
originalFilePath = fullPath;
var audioFormatConvertorSession =
new AudioFormatConvertorSession(
//AudioFormatConvertorSession.TEMP_AUDIO_DIRECTORY,
treeNode.Presentation.DataProviderManager.DataFileDirectoryFullPath,
treeNode.Presentation.MediaDataManager.DefaultPCMFormat,
false,
m_UrakawaSession.IsAcmCodecsDisabled);
//filePath = m_AudioFormatConvertorSession.ConvertAudioFileFormat(filePath);
bool cancelled = false;
var converter = new AudioClipConverter(audioFormatConvertorSession, fullPath);
bool error = ShellView.RunModalCancellableProgressTask(true,
"Converting audio...",
converter,
() =>
{
m_Logger.Log(@"Audio conversion CANCELLED", Category.Debug, Priority.Medium);
cancelled = true;
},
() =>
{
m_Logger.Log(@"Audio conversion DONE", Category.Debug, Priority.Medium);
cancelled = false;
});
if (cancelled)
{
//DebugFix.Assert(!result);
break;
}
fullPath = converter.ConvertedFilePath;
if (string.IsNullOrEmpty(fullPath))
{
break;
}
m_Logger.Log(string.Format("Converted audio {0} to {1}", originalFilePath, fullPath),
Category.Debug, Priority.Medium);
//Stream fileStream = File.Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
//try
//{
// uint dataLength;
// wavFormat = AudioLibPCMFormat.RiffHeaderParse(fileStream, out dataLength);
//}
//finally
//{
// fileStream.Close();
//}
}
ManagedAudioMedia manAudioMedia = treeNode.Presentation.MediaFactory.CreateManagedAudioMedia();
AudioMediaData audioMediaData = treeNode.Presentation.MediaDataFactory.CreateAudioMediaData(DataProviderFactory.AUDIO_WAV_EXTENSION);
manAudioMedia.AudioMediaData = audioMediaData;
FileDataProvider dataProv = (FileDataProvider)treeNode.Presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
dataProv.InitByCopyingExistingFile(fullPath);
audioMediaData.AppendPcmData(dataProv);
// Stream wavStream = null;
// try
// {
// wavStream = File.Open(fullPath, FileMode.Open, FileAccess.Read, FileShare.Read);
// uint dataLength;
// AudioLibPCMFormat pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
// if (!treeNode.Presentation.MediaDataManager.DefaultPCMFormat.Data.IsCompatibleWith(pcmInfo))
// {
//#if DEBUG
// Debugger.Break();
//#endif //DEBUG
// wavStream.Close();
// wavStream = null;
// var audioFormatConvertorSession =
// new AudioFormatConvertorSession(
// //AudioFormatConvertorSession.TEMP_AUDIO_DIRECTORY,
// treeNode.Presentation.DataProviderManager.DataFileDirectoryFullPath,
// treeNode.Presentation.MediaDataManager.DefaultPCMFormat, m_UrakawaSession.IsAcmCodecsDisabled);
// string newfullWavPath = audioFormatConvertorSession.ConvertAudioFileFormat(fullPath);
// FileDataProvider dataProv = (FileDataProvider)treeNode.Presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
// dataProv.InitByMovingExistingFile(newfullWavPath);
// audioMediaData.AppendPcmData(dataProv);
// }
// else // use original wav file by copying it to data directory
// {
// FileDataProvider dataProv = (FileDataProvider)treeNode.Presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
// dataProv.InitByCopyingExistingFile(fullPath);
// audioMediaData.AppendPcmData(dataProv);
// }
// }
// finally
// {
// if (wavStream != null) wavStream.Close();
// }
AlternateContentSetManagedMediaCommand cmd_AltContent_diagramElement_Audio =
treeNode.Presentation.CommandFactory.CreateAlternateContentSetManagedMediaCommand(treeNode, altContent, manAudioMedia);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_diagramElement_Audio);
//SetDescriptionAudio(altContent, audio, treeNode);
}
}
else
{
Metadata diagramElementAttribute_Metadata = treeNode.Presentation.MetadataFactory.CreateMetadata();
diagramElementAttribute_Metadata.NameContentAttribute = new MetadataAttribute();
diagramElementAttribute_Metadata.NameContentAttribute.Name = attribute.Name;
diagramElementAttribute_Metadata.NameContentAttribute.NamespaceUri = attribute.NamespaceURI;
diagramElementAttribute_Metadata.NameContentAttribute.Value = attribute.Value;
AlternateContentMetadataAddCommand cmd_AltContent_diagramElementAttribute_Metadata =
treeNode.Presentation.CommandFactory.CreateAlternateContentMetadataAddCommand(
treeNode,
null,
altContent,
diagramElementAttribute_Metadata,
null
);
treeNode.Presentation.UndoRedoManager.Execute(
cmd_AltContent_diagramElementAttribute_Metadata);
}
}
}
int nObjects = -1;
XmlNode textNode = diagramElementNode;
if (diagramElementName == DiagramContentModelHelper.D_SimplifiedImage ||
diagramElementName == DiagramContentModelHelper.D_Tactile)
{
string localTourName = DiagramContentModelHelper.StripNSPrefix(DiagramContentModelHelper.D_Tour);
XmlNode tour =
XmlDocumentHelper.GetFirstChildElementOrSelfWithName(diagramElementNode, false,
localTourName,
DiagramContentModelHelper.NS_URL_DIAGRAM);
textNode = tour;
IEnumerable <XmlNode> objects = XmlDocumentHelper.GetChildrenElementsOrSelfWithName(diagramElementNode, false,
DiagramContentModelHelper.
Object,
DiagramContentModelHelper.
NS_URL_ZAI, false);
nObjects = 0;
foreach (XmlNode obj in objects)
{
nObjects++;
}
int i = -1;
foreach (XmlNode obj in objects)
{
i++;
if (i != objectIndex)
{
continue;
}
if (obj.Attributes == null || obj.Attributes.Count <= 0)
{
break;
}
for (int j = 0; j < obj.Attributes.Count; j++)
{
XmlAttribute attribute = obj.Attributes[j];
if (attribute.Name.StartsWith(XmlReaderWriterHelper.NS_PREFIX_XMLNS + ":"))
{
//
}
else if (attribute.Name == XmlReaderWriterHelper.NS_PREFIX_XMLNS)
{
//
}
else if (attribute.Name == DiagramContentModelHelper.Src)
{
//
}
else if (attribute.Name == DiagramContentModelHelper.SrcType)
{
//
}
else
{
Metadata diagramElementAttribute_Metadata = treeNode.Presentation.MetadataFactory.CreateMetadata();
diagramElementAttribute_Metadata.NameContentAttribute = new MetadataAttribute();
diagramElementAttribute_Metadata.NameContentAttribute.Name = attribute.Name;
diagramElementAttribute_Metadata.NameContentAttribute.NamespaceUri = attribute.NamespaceURI;
diagramElementAttribute_Metadata.NameContentAttribute.Value = attribute.Value;
AlternateContentMetadataAddCommand cmd_AltContent_diagramElementAttribute_Metadata =
treeNode.Presentation.CommandFactory.CreateAlternateContentMetadataAddCommand(
treeNode,
null,
altContent,
diagramElementAttribute_Metadata,
null
);
treeNode.Presentation.UndoRedoManager.Execute(
cmd_AltContent_diagramElementAttribute_Metadata);
}
}
XmlAttribute srcAttr = (XmlAttribute)obj.Attributes.GetNamedItem(DiagramContentModelHelper.Src);
if (srcAttr != null)
{
XmlAttribute srcType =
(XmlAttribute)obj.Attributes.GetNamedItem(DiagramContentModelHelper.SrcType);
ManagedImageMedia img = treeNode.Presentation.MediaFactory.CreateManagedImageMedia();
string imgFullPath = null;
if (FileDataProvider.isHTTPFile(srcAttr.Value))
{
imgFullPath = FileDataProvider.EnsureLocalFilePathDownloadTempDirectory(srcAttr.Value);
}
else
{
imgFullPath = Path.Combine(Path.GetDirectoryName(xmlFilePath), srcAttr.Value);
}
if (imgFullPath != null && File.Exists(imgFullPath))
{
string extension = Path.GetExtension(imgFullPath);
ImageMediaData imgData = treeNode.Presentation.MediaDataFactory.CreateImageMediaData(extension);
if (imgData != null)
{
imgData.InitializeImage(imgFullPath, Path.GetFileName(imgFullPath));
img.ImageMediaData = imgData;
AlternateContentSetManagedMediaCommand cmd_AltContent_Image =
treeNode.Presentation.CommandFactory.CreateAlternateContentSetManagedMediaCommand(
treeNode, altContent, img);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_Image);
}
}
}
}
}
if (textNode != null)
{
string strText = textNode.InnerXml;
if (!string.IsNullOrEmpty(strText))
{
strText = strText.Trim();
strText = Regex.Replace(strText, @"\s+", " ");
strText = strText.Replace("\r\n", "\n");
}
if (!string.IsNullOrEmpty(strText))
{
TextMedia txtMedia = treeNode.Presentation.MediaFactory.CreateTextMedia();
txtMedia.Text = strText;
AlternateContentSetManagedMediaCommand cmd_AltContent_Text =
treeNode.Presentation.CommandFactory.CreateAlternateContentSetManagedMediaCommand(treeNode,
altContent,
txtMedia);
treeNode.Presentation.UndoRedoManager.Execute(cmd_AltContent_Text);
}
}
if (nObjects > 0 && ++objectIndex <= nObjects - 1)
{
diagramXmlParseBody_(diagramElementNode, xmlFilePath, treeNode, objectIndex);
}
}
/// <summary>
/// takes wav file / mp3 file as input and converts it to wav file with audio format info supplied as parameter
/// </summary>
/// <param name="SourceFilePath"></param>
/// <param name="destinationDirectory"></param>
/// <param name="destinationFormatInfo"></param>
/// <returns> full file path of converted file </returns>
private string ConvertToDefaultFormat(string SourceFilePath, string destinationDirectory, PCMFormatInfo destinationFormatInfo, bool skipACM)
{
if (!File.Exists(SourceFilePath))
{
throw new FileNotFoundException(SourceFilePath);
}
if (!Directory.Exists(destinationDirectory))
{
FileDataProvider.CreateDirectory(destinationDirectory);
}
AudioFileType sourceFileType = GetAudioFileType(SourceFilePath);
switch (sourceFileType)
{
case AudioFileType.WavUncompressed:
case AudioFileType.WavCompressed:
{
if (FirstDiscoveredPCMFormat == null)
{
Stream wavStream = null;
try
{
wavStream = File.Open(SourceFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
uint dataLength;
AudioLibPCMFormat pcmInfo = null;
pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
//FirstDiscoveredPCMFormat = new PCMFormatInfo(pcmInfo);
FirstDiscoveredPCMFormat = new AudioLibPCMFormat();
FirstDiscoveredPCMFormat.CopyFrom(pcmInfo);
}
finally
{
if (wavStream != null)
{
wavStream.Close();
}
}
}
WavFormatConverter formatConverter1 = new WavFormatConverter(true, skipACM);
AddSubCancellable(formatConverter1);
// Preserve existing WAV PCM format, the call below to ConvertSampleRate detects the equality of PCM formats and copies the audio file instead of resampling.
AudioLibPCMFormat pcmFormat = m_autoDetectPcmFormat ? FirstDiscoveredPCMFormat :
(destinationFormatInfo != null ? destinationFormatInfo.Data : new AudioLibPCMFormat());
string result = null;
try
{
AudioLibPCMFormat originalPcmFormat;
result = formatConverter1.ConvertSampleRate(SourceFilePath, destinationDirectory,
pcmFormat,
out originalPcmFormat);
if (originalPcmFormat != null && FirstDiscoveredPCMFormat != null)
{
DebugFix.Assert(FirstDiscoveredPCMFormat.Equals(originalPcmFormat));
}
}
finally
{
RemoveSubCancellable(formatConverter1);
}
return(result);
}
case AudioFileType.Mp4_AAC:
case AudioFileType.Mp3:
{
WavFormatConverter formatConverter2 = new WavFormatConverter(true, skipACM);
AddSubCancellable(formatConverter2);
string result = null;
try
{
AudioLibPCMFormat pcmFormat = m_autoDetectPcmFormat ? FirstDiscoveredPCMFormat : // can be null!
(destinationFormatInfo != null ? destinationFormatInfo.Data : new AudioLibPCMFormat());
AudioLibPCMFormat originalPcmFormat;
if (sourceFileType == AudioFileType.Mp3)
{
result = formatConverter2.UnCompressMp3File(SourceFilePath, destinationDirectory,
pcmFormat,
out originalPcmFormat);
}
else
{
DebugFix.Assert(sourceFileType == AudioFileType.Mp4_AAC);
result = formatConverter2.UnCompressMp4_AACFile(SourceFilePath, destinationDirectory,
pcmFormat,
out originalPcmFormat);
}
if (originalPcmFormat != null)
{
if (FirstDiscoveredPCMFormat == null)
{
//FirstDiscoveredPCMFormat = new PCMFormatInfo(originalPcmFormat);
FirstDiscoveredPCMFormat = new AudioLibPCMFormat();
FirstDiscoveredPCMFormat.CopyFrom(originalPcmFormat);
}
}
}
finally
{
RemoveSubCancellable(formatConverter2);
}
return(result);
}
default:
throw new Exception("Source file format not supported");
}
}
/// <summary>
/// Gets an input <see cref="Stream"/> providing read access to the raw PCM audio data
/// between given sub-clip begin and end times
/// </summary>
/// <param name="subClipBegin">The beginning of the sub-clip</param>
/// <param name="subClipEnd">The end of the sub-clip</param>
/// <returns>The raw PCM audio data <see cref="Stream"/></returns>
/// <remarks>
/// <para>Sub-clip times must be in the interval <c>[0;this.getAudioDuration()]</c>.</para>
/// <para>
/// The sub-clip is
/// relative to clip begin of the WavClip, that if <c>this.getClipBegin()</c>
/// returns <c>00:00:10</c>, <c>this.getClipEnd()</c> returns <c>00:00:50</c>,
/// <c>x</c> and <c>y</c> is <c>00:00:05</c> and <c>00:00:30</c> respectively,
/// then <c>this.GetAudioData(x, y)</c> will get the audio in the underlying wave audio between
/// <c>00:00:15</c> and <c>00:00:40</c>
/// </para>
/// </remarks>
public Stream OpenPcmInputStream(Time subClipBegin, Time subClipEnd)
{
if (subClipBegin == null)
{
throw new exception.MethodParameterIsNullException("subClipBegin must not be null");
}
if (subClipEnd == null)
{
throw new exception.MethodParameterIsNullException("subClipEnd must not be null");
}
if (
subClipBegin.IsLessThan(Time.Zero) ||
subClipEnd.IsLessThan(subClipBegin) ||
subClipEnd.IsGreaterThan(Duration)
)
{
string msg = String.Format(
"subClipBegin/subClipEnd [{0};{1}] not within ([0;{2}])",
subClipBegin, subClipEnd, Duration);
throw new exception.MethodParameterIsOutOfBoundsException(msg);
}
Stream raw = DataProvider.OpenInputStream();
uint dataLength;
AudioLibPCMFormat format = AudioLibPCMFormat.RiffHeaderParse(raw, out dataLength);
Time rawEndTime = new Time(format.ConvertBytesToTime(dataLength));
#if DEBUG
DebugFix.Assert(rawEndTime.IsEqualTo(MediaDuration));
#endif
//Time rawEndTime = Time.Zero.Add(MediaDuration); // We don't call this to avoid unnecessary I/O (Strem.Open() twice)
if (
ClipBegin.IsLessThan(Time.Zero) ||
ClipBegin.IsGreaterThan(ClipEnd) ||
ClipEnd.IsGreaterThan(rawEndTime)
)
{
string msg = String.Format(
"WavClip [{0};{1}] is empty or not within the underlying wave data stream ([0;{2}])",
ClipBegin, ClipEnd, rawEndTime);
throw new exception.InvalidDataFormatException(msg);
}
/*
* Time clipDuration = Duration;
* if (subClipBegin.IsEqualTo(Time.Zero) && subClipEnd.IsEqualTo(Time.Zero.Add(clipDuration)))
* {
* // Stream.Position is at the end of the RIFF header, we need to bring it back to the begining
* return new SubStream(
* raw,
* raw.Position, raw.Length - raw.Position);
* }
*/
//Time rawClipBegin = new Time(ClipBegin.AsTimeSpan + subClipBegin.AsTimeSpan);
//Time rawClipEnd = new Time(ClipBegin.AsTimeSpan + subClipEnd.AsTimeSpan);
long ClipBegin_AsLocalUnits = ClipBegin.AsLocalUnits;
long posRiffHeader = raw.Position; //44
long beginPos = posRiffHeader + format.ConvertTimeToBytes(ClipBegin_AsLocalUnits + subClipBegin.AsLocalUnits);
long endPos = posRiffHeader + format.ConvertTimeToBytes(ClipBegin_AsLocalUnits + subClipEnd.AsLocalUnits);
long rawLen = raw.Length;
#if DEBUG
long rawLenCheck = posRiffHeader + dataLength;
DebugFix.Assert(rawLen == rawLenCheck);
#endif
if (endPos > rawLen)
{
//#if DEBUG
// Debugger.Break();
//#endif
endPos = rawLen;
}
long len = endPos - beginPos;
return(new SubStream(
raw,
beginPos,
len,
DataProvider is FileDataProvider ? ((FileDataProvider)DataProvider).DataFileFullPath : null));
}
protected void addAudio(TreeNode treeNode, XmlNode xmlNode, bool isSequence, string fullSmilPath)
{
if (RequestCancellation)
{
return;
}
string dirPath = Path.GetDirectoryName(fullSmilPath);
XmlAttributeCollection audioAttrs = xmlNode.Attributes;
if (audioAttrs == null || audioAttrs.Count == 0)
{
return;
}
XmlNode audioAttrSrc = audioAttrs.GetNamedItem("src");
if (audioAttrSrc == null || String.IsNullOrEmpty(audioAttrSrc.Value))
{
return;
}
string src = FileDataProvider.UriDecode(audioAttrSrc.Value);
XmlNode audioAttrClipBegin = audioAttrs.GetNamedItem("clipBegin");
XmlNode audioAttrClipEnd = audioAttrs.GetNamedItem("clipEnd");
Presentation presentation = treeNode.Presentation; // m_Project.Presentations.Get(0);
ManagedAudioMedia media = null;
string fullPath = Path.Combine(dirPath, src);
fullPath = FileDataProvider.NormaliseFullFilePath(fullPath).Replace('/', '\\');
addOPF_GlobalAssetPath(fullPath);
string ext = Path.GetExtension(src);
if (ext.Equals(DataProviderFactory.AUDIO_WAV_EXTENSION, StringComparison.OrdinalIgnoreCase))
{
FileDataProvider dataProv = null;
if (!File.Exists(fullPath))
{
Debug.Fail("File not found: " + fullPath);
media = null;
}
else
{
//bool deleteSrcAfterCompletion = false;
string fullWavPath = fullPath;
FileDataProvider obj;
m_OriginalAudioFile_FileDataProviderMap.TryGetValue(fullWavPath, out obj);
if (obj != null) //m_OriginalAudioFile_FileDataProviderMap.ContainsKey(fullWavPath))
{
if (m_AudioConversionSession.FirstDiscoveredPCMFormat == null)
{
DebugFix.Assert(obj.Presentation != presentation);
Object appData = obj.AppData;
DebugFix.Assert(appData != null);
if (appData != null && appData is WavClip.PcmFormatAndTime)
{
m_AudioConversionSession.FirstDiscoveredPCMFormat = new AudioLibPCMFormat();
m_AudioConversionSession.FirstDiscoveredPCMFormat.CopyFrom(((WavClip.PcmFormatAndTime)appData).mFormat);
}
}
if (obj.Presentation != presentation)
{
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.CopyingAudio, Path.GetFileName(obj.DataFileFullPath)));
dataProv.InitByCopyingExistingFile(obj.DataFileFullPath);
//m_AudioConversionSession.RelocateDestinationFilePath(newfullWavPath, dataProv.DataFileFullPath);
m_OriginalAudioFile_FileDataProviderMap.Remove(fullWavPath);
m_OriginalAudioFile_FileDataProviderMap.Add(fullWavPath, dataProv);
Object appData = obj.AppData;
DebugFix.Assert(appData != null);
if (appData != null && appData is WavClip.PcmFormatAndTime)
{
dataProv.AppData = new WavClip.PcmFormatAndTime(((WavClip.PcmFormatAndTime)appData).mFormat, ((WavClip.PcmFormatAndTime)appData).mTime);
}
}
else
{
dataProv = obj; // m_OriginalAudioFile_FileDataProviderMap[fullWavPath];
}
}
else // create FileDataProvider
{
Stream wavStream = null;
try
{
wavStream = File.Open(fullWavPath, FileMode.Open, FileAccess.Read, FileShare.Read);
uint dataLength;
AudioLibPCMFormat pcmInfo = null;
pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
if (m_AudioConversionSession.FirstDiscoveredPCMFormat == null)
{
//m_AudioConversionSession.FirstDiscoveredPCMFormat = new PCMFormatInfo(pcmInfo);
m_AudioConversionSession.FirstDiscoveredPCMFormat = new AudioLibPCMFormat();
m_AudioConversionSession.FirstDiscoveredPCMFormat.CopyFrom(pcmInfo);
}
if (RequestCancellation)
{
return;
}
//if (m_firstTimePCMFormat)
//{
// presentation.MediaDataManager.DefaultPCMFormat = new PCMFormatInfo(pcmInfo);
// m_firstTimePCMFormat = false;
//}
if (!presentation.MediaDataManager.DefaultPCMFormat.Data.IsCompatibleWith(pcmInfo))
{
wavStream.Close();
wavStream = null;
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.ConvertingAudio, Path.GetFileName(fullWavPath)));
string newfullWavPath = m_AudioConversionSession.ConvertAudioFileFormat(fullWavPath);
if (RequestCancellation)
{
return;
}
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
//Console.WriteLine("Source audio file to SDK audio file map (before creating SDK audio file): " + Path.GetFileName(fullWavPath) + " = " + dataProv.DataFileRelativePath);
dataProv.InitByMovingExistingFile(newfullWavPath);
m_AudioConversionSession.RelocateDestinationFilePath(newfullWavPath, dataProv.DataFileFullPath);
m_OriginalAudioFile_FileDataProviderMap.Add(fullWavPath, dataProv);
if (RequestCancellation)
{
return;
}
}
else // use original wav file by copying it to data directory
{
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
//Console.WriteLine("Source audio file to SDK audio file map (before creating SDK audio file): " + Path.GetFileName(fullWavPath) + " = " + dataProv.DataFileRelativePath);
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.CopyingAudio, Path.GetFileName(fullWavPath)));
dataProv.InitByCopyingExistingFile(fullWavPath);
m_OriginalAudioFile_FileDataProviderMap.Add(fullWavPath, dataProv);
if (RequestCancellation)
{
return;
}
}
}
finally
{
if (wavStream != null)
{
wavStream.Close();
}
}
}
} // FileDataProvider key check ends
if (RequestCancellation)
{
return;
}
media = addAudioWav(dataProv, audioAttrClipBegin, audioAttrClipEnd, treeNode);
//media = addAudioWav ( fullWavPath, deleteSrcAfterCompletion, audioAttrClipBegin, audioAttrClipEnd );
}
else if (ext.Equals(DataProviderFactory.AUDIO_MP3_EXTENSION, StringComparison.OrdinalIgnoreCase) ||
ext.Equals(DataProviderFactory.AUDIO_MP4_EXTENSION, StringComparison.OrdinalIgnoreCase) ||
ext.Equals(DataProviderFactory.AUDIO_MP4_EXTENSION_, StringComparison.OrdinalIgnoreCase))
{
if (!File.Exists(fullPath))
{
Debug.Fail("File not found: {0}", fullPath);
return;
}
if (RequestCancellation)
{
return;
}
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.DecodingAudio, Path.GetFileName(fullPath)));
if (RequestCancellation)
{
return;
}
string fullMp34PathOriginal = fullPath;
FileDataProvider obj;
m_OriginalAudioFile_FileDataProviderMap.TryGetValue(fullMp34PathOriginal, out obj);
FileDataProvider dataProv = null;
if (obj != null) //m_OriginalAudioFile_FileDataProviderMap.ContainsKey(fullMp3PathOriginal))
{
if (m_AudioConversionSession.FirstDiscoveredPCMFormat == null)
{
DebugFix.Assert(obj.Presentation != presentation);
Object appData = obj.AppData;
DebugFix.Assert(appData != null);
if (appData != null && appData is WavClip.PcmFormatAndTime)
{
m_AudioConversionSession.FirstDiscoveredPCMFormat = new AudioLibPCMFormat();
m_AudioConversionSession.FirstDiscoveredPCMFormat.CopyFrom(((WavClip.PcmFormatAndTime)appData).mFormat);
}
}
if (obj.Presentation != presentation)
{
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.CopyingAudio, Path.GetFileName(obj.DataFileFullPath)));
dataProv.InitByCopyingExistingFile(obj.DataFileFullPath);
//m_AudioConversionSession.RelocateDestinationFilePath(newfullWavPath, dataProv.DataFileFullPath);
m_OriginalAudioFile_FileDataProviderMap.Remove(fullMp34PathOriginal);
m_OriginalAudioFile_FileDataProviderMap.Add(fullMp34PathOriginal, dataProv);
Object appData = obj.AppData;
DebugFix.Assert(appData != null);
if (appData != null && appData is WavClip.PcmFormatAndTime)
{
dataProv.AppData = new WavClip.PcmFormatAndTime(((WavClip.PcmFormatAndTime)appData).mFormat, ((WavClip.PcmFormatAndTime)appData).mTime);
}
}
else
{
dataProv = obj; // m_OriginalAudioFile_FileDataProviderMap[fullMp3PathOriginal];
}
}
else
{
string newfullWavPath = m_AudioConversionSession.ConvertAudioFileFormat(fullMp34PathOriginal);
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
//Console.WriteLine("Source audio file to SDK audio file map (before creating SDK audio file): " + Path.GetFileName(fullMp34PathOriginal) + " = " + dataProv.DataFileRelativePath);
dataProv.InitByMovingExistingFile(newfullWavPath);
m_AudioConversionSession.RelocateDestinationFilePath(newfullWavPath, dataProv.DataFileFullPath);
m_OriginalAudioFile_FileDataProviderMap.Add(fullMp34PathOriginal, dataProv);
if (RequestCancellation)
{
return;
}
}
if (dataProv != null)
{
//if (m_firstTimePCMFormat)
//{
// Stream wavStream = null;
// try
// {
// wavStream = File.Open(newfullWavPath, FileMode.Open, FileAccess.Read, FileShare.Read);
// uint dataLength;
// AudioLibPCMFormat pcmInfo = null;
// pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
// presentation.MediaDataManager.DefaultPCMFormat = new PCMFormatInfo(pcmInfo);
// }
// finally
// {
// if (wavStream != null) wavStream.Close();
// m_firstTimePCMFormat = false;
// }
//}
if (RequestCancellation)
{
return;
}
//media = addAudioWav(newfullWavPath, true, audioAttrClipBegin, audioAttrClipEnd);
media = addAudioWav(dataProv, audioAttrClipBegin, audioAttrClipEnd, treeNode);
if (RequestCancellation)
{
return;
}
if (media == null)
{
#if DEBUG
Debugger.Break();
#endif
}
}
//}
}
if (RequestCancellation)
{
return;
}
if (media == null)
{
if (!TreenodesWithoutManagedAudioMediaData.Contains(treeNode))
{
TreenodesWithoutManagedAudioMediaData.Add(treeNode);
}
Debug.Fail("Creating ExternalAudioMedia ??");
Time timeClipBegin = null;
ExternalAudioMedia exmedia = presentation.MediaFactory.CreateExternalAudioMedia();
exmedia.Src = src;
if (audioAttrClipBegin != null &&
!string.IsNullOrEmpty(audioAttrClipBegin.Value))
{
timeClipBegin = new Time();
try
{
timeClipBegin = new Time(audioAttrClipBegin.Value);
}
catch (Exception ex)
{
string str = "CLIP BEGIN TIME PARSE FAIL: " + audioAttrClipBegin.Value;
Console.WriteLine(str);
Debug.Fail(str);
}
exmedia.ClipBegin = timeClipBegin;
}
if (audioAttrClipEnd != null &&
!string.IsNullOrEmpty(audioAttrClipEnd.Value))
{
Time timeClipEnd = null;
try
{
timeClipEnd = new Time(audioAttrClipEnd.Value);
}
catch (Exception ex)
{
string str = "CLIP END TIME PARSE FAIL: " + audioAttrClipEnd.Value;
Console.WriteLine(str);
Debug.Fail(str);
}
if (timeClipEnd != null)
{
try
{
exmedia.ClipEnd = timeClipEnd;
}
catch (Exception ex)
{
string str = "CLIP TIME ERROR (end < begin): " + timeClipBegin + " (" + (audioAttrClipBegin != null ? audioAttrClipBegin.Value : "N/A") + ") / " + timeClipEnd + " (" + audioAttrClipEnd.Value + ")";
Console.WriteLine(str);
//Debug.Fail(str);
}
}
}
}
if (RequestCancellation)
{
return;
}
if (media != null)
{
ChannelsProperty chProp =
treeNode.GetChannelsProperty();
if (chProp == null)
{
chProp =
presentation.PropertyFactory.CreateChannelsProperty();
treeNode.AddProperty(chProp);
}
if (isSequence)
{
#if ENABLE_SEQ_MEDIA
SequenceMedia mediaSeq = chProp.GetMedia(m_audioChannel) as SequenceMedia;
if (mediaSeq == null)
{
mediaSeq = presentation.MediaFactory.CreateSequenceMedia();
mediaSeq.AllowMultipleTypes = false;
chProp.SetMedia(m_audioChannel, mediaSeq);
}
mediaSeq.ChildMedias.Insert(mediaSeq.ChildMedias.Count, media);
#else
ManagedAudioMedia existingMedia = chProp.GetMedia(presentation.ChannelsManager.GetOrCreateAudioChannel()) as ManagedAudioMedia;
if (existingMedia == null)
{
chProp.SetMedia(presentation.ChannelsManager.GetOrCreateAudioChannel(), media);
}
else
{
// WARNING: WavAudioMediaData implementation differs from AudioMediaData:
// the latter is naive and performs a stream binary copy, the latter is optimized and re-uses existing WavClips.
// WARNING 2: The audio data from the given parameter gets emptied !
existingMedia.AudioMediaData.MergeWith(media.AudioMediaData);
//Stream stream = seqManMedia.AudioMediaData.OpenPcmInputStream();
//try
//{
// mediaData.AppendPcmData(stream, null);
//}
//finally
//{
// stream.Close();
//}
}
#endif //ENABLE_SEQ_MEDIA
}
else
{
//#if DEBUG
// ((WavAudioMediaData) media.AudioMediaData).checkWavClips();
//#endif //DEBUG
chProp.SetMedia(presentation.ChannelsManager.GetOrCreateAudioChannel(), media);
}
}
else
{
Debug.Fail("Media could not be created !");
}
}
private void checkAndAddDeferredRecordingDataItems()
{
if (m_DeferredRecordingDataItems == null)
{
return;
}
IsAutoPlay = false;
bool needsRefresh = false;
bool skipDrawing = Settings.Default.AudioWaveForm_DisableDraw;
Settings.Default.AudioWaveForm_DisableDraw = true;
//#if !DISABLE_SINGLE_RECORD_FILE
string previousRecordedFile = null;
FileDataProvider currentFileDataProvider = null;
AudioLibPCMFormat currentPcmFormat = null;
long currentPcmDataLength = -1;
long previousBytePosEnd = 0;
//#endif
foreach (var deferredRecordingDataItem in m_DeferredRecordingDataItems)
{
Tuple <TreeNode, TreeNode> treeNodeSelection = m_UrakawaSession.PerformTreeNodeSelection(deferredRecordingDataItem.TreeNode1, false, deferredRecordingDataItem.TreeNode2);
if (treeNodeSelection.Item1 != deferredRecordingDataItem.TreeNode1 ||
treeNodeSelection.Item2 != deferredRecordingDataItem.TreeNode2)
{
#if DEBUG
Debugger.Break();
#endif
continue;
}
if (IsWaveFormLoading && View != null)
{
View.CancelWaveFormLoad(true);
}
if (deferredRecordingDataItem.PlayBytePosition >= 0)
{
PlayBytePosition = deferredRecordingDataItem.PlayBytePosition;
}
else
{
m_LastSetPlayBytePosition = deferredRecordingDataItem.PlayBytePosition;
}
if (PlayBytePosition != deferredRecordingDataItem.PlayBytePosition)
{
#if DEBUG
Debugger.Break();
#endif
continue;
}
if (deferredRecordingDataItem.SelectionBeginBytePosition >= 0 &&
deferredRecordingDataItem.SelectionEndBytePosition > 0)
{
State.Selection.SetSelectionBytes(deferredRecordingDataItem.SelectionBeginBytePosition, deferredRecordingDataItem.SelectionEndBytePosition);
}
else
{
State.Selection.ClearSelection();
}
if (State.Selection.SelectionBeginBytePosition != deferredRecordingDataItem.SelectionBeginBytePosition ||
State.Selection.SelectionEndBytePosition != deferredRecordingDataItem.SelectionEndBytePosition)
{
#if DEBUG
Debugger.Break();
#endif
continue;
}
if (!Settings.Default.Audio_DisableSingleWavFileRecord)
{
TreeNode treeNode = deferredRecordingDataItem.TreeNode1 ?? deferredRecordingDataItem.TreeNode2;
if (string.IsNullOrEmpty(previousRecordedFile) ||
previousRecordedFile != deferredRecordingDataItem.RecordedFilePath)
{
PCMFormatInfo pcmInfo = State.Audio.PcmFormatRecordingMonitoring;
currentPcmFormat = (pcmInfo != null ? pcmInfo.Copy().Data : null);
if (currentPcmFormat == null)
{
Stream fileStream = File.Open(deferredRecordingDataItem.RecordedFilePath, FileMode.Open, FileAccess.Read,
FileShare.Read);
try
{
uint dataLength;
currentPcmFormat = AudioLibPCMFormat.RiffHeaderParse(fileStream, out dataLength);
currentPcmDataLength = dataLength;
}
finally
{
fileStream.Close();
}
}
currentFileDataProvider =
(FileDataProvider)treeNode.Presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
currentFileDataProvider.InitByMovingExistingFile(deferredRecordingDataItem.RecordedFilePath);
if (File.Exists(deferredRecordingDataItem.RecordedFilePath))
//check exist just in case file adopted by DataProviderManager
{
File.Delete(deferredRecordingDataItem.RecordedFilePath);
}
}
//Time duration = new Time(currentPcmFormat.ConvertBytesToTime(currentPcmDataLength));
if (previousBytePosEnd < 0)
{
previousBytePosEnd = 0;
}
long bytePosEnd = deferredRecordingDataItem.RecordAndContinue_StopBytePos;
openFile(treeNode, currentFileDataProvider, previousBytePosEnd, bytePosEnd, currentPcmFormat, currentPcmDataLength);
}
else
{
openFile(deferredRecordingDataItem.RecordedFilePath, true, true,
State.Audio.PcmFormatRecordingMonitoring);
}
needsRefresh = true;
//m_viewModel.CommandRefresh.Execute();
//if (m_viewModel.View != null)
//{
// m_viewModel.View.CancelWaveFormLoad(true);
//}
if (!Settings.Default.Audio_DisableSingleWavFileRecord)
{
previousRecordedFile = deferredRecordingDataItem.RecordedFilePath;
previousBytePosEnd = deferredRecordingDataItem.RecordAndContinue_StopBytePos;
}
}
m_DeferredRecordingDataItems = null;
Settings.Default.AudioWaveForm_DisableDraw = skipDrawing;
if (needsRefresh)
{
CommandRefresh.Execute();
}
}
private void verifyTree(TreeNode node, bool ancestorHasAudio, string ancestorExtAudioFile)
{
if (TreeNodeMustBeSkipped(node))
{
return;
}
if (TreeNodeTriggersNewAudioFile(node) && ancestorExtAudioFile == null)
{
ancestorExtAudioFile = "";
}
Media manSeqMedia = node.GetManagedAudioMediaOrSequenceMedia();
if (ancestorHasAudio)
{
DebugFix.Assert(manSeqMedia == null);
}
if (node.HasChannelsProperty)
{
ChannelsProperty chProp = node.GetChannelsProperty();
Media media = chProp.GetMedia(DestinationChannel);
if (ancestorHasAudio)
{
DebugFix.Assert(media == null);
}
if (media != null)
{
DebugFix.Assert(media is ExternalAudioMedia);
DebugFix.Assert(manSeqMedia != null);
if (!ancestorHasAudio)
{
ExternalAudioMedia extMedia = (ExternalAudioMedia)media;
ancestorHasAudio = true;
if (ancestorExtAudioFile != null)
{
if (ancestorExtAudioFile == "")
{
ancestorExtAudioFile = extMedia.Uri.LocalPath;
}
else
{
DebugFix.Assert(ancestorExtAudioFile == extMedia.Uri.LocalPath);
}
}
else
{
ancestorExtAudioFile = extMedia.Uri.LocalPath;
}
string ext = Path.GetExtension(ancestorExtAudioFile);
if (!DataProviderFactory.AUDIO_WAV_EXTENSION.Equals(ext, StringComparison.OrdinalIgnoreCase))
{
Debug.Fail("Verification can only be done if external media points to wav file!");
}
//reportProgress(-1, @"DEBUG: " + ancestorExtAudioFile);
Stream extMediaStream = new FileStream(ancestorExtAudioFile, FileMode.Open, FileAccess.Read,
FileShare.None);
Stream manMediaStream = null;
ManagedAudioMedia manMedia = node.GetManagedAudioMedia();
#if ENABLE_SEQ_MEDIA
SequenceMedia seqMedia = node.GetManagedAudioSequenceMedia();
#endif //ENABLE_SEQ_MEDIA
if (manMedia != null)
{
#if ENABLE_SEQ_MEDIA
DebugFix.Assert(seqMedia == null);
#endif //ENABLE_SEQ_MEDIA
DebugFix.Assert(manMedia.HasActualAudioMediaData);
manMediaStream = manMedia.AudioMediaData.OpenPcmInputStream();
}
else
{
Debug.Fail("SequenceMedia is normally removed at import time...have you tried re-importing the DAISY book ?");
#if ENABLE_SEQ_MEDIA
DebugFix.Assert(seqMedia != null);
DebugFix.Assert(!seqMedia.AllowMultipleTypes);
DebugFix.Assert(seqMedia.ChildMedias.Count > 0);
DebugFix.Assert(seqMedia.ChildMedias.Get(0) is ManagedAudioMedia);
manMediaStream = seqMedia.OpenPcmInputStreamOfManagedAudioMedia();
#endif //ENABLE_SEQ_MEDIA
}
try
{
uint extMediaPcmLength;
AudioLibPCMFormat pcmInfo = AudioLibPCMFormat.RiffHeaderParse(extMediaStream,
out extMediaPcmLength);
DebugFix.Assert(extMediaPcmLength == extMediaStream.Length - extMediaStream.Position);
if (manMedia != null)
{
DebugFix.Assert(pcmInfo.IsCompatibleWith(manMedia.AudioMediaData.PCMFormat.Data));
}
#if ENABLE_SEQ_MEDIA
if (seqMedia != null)
{
DebugFix.Assert(
pcmInfo.IsCompatibleWith(
((ManagedAudioMedia)seqMedia.ChildMedias.Get(0)).AudioMediaData.PCMFormat.Data));
}
#endif //ENABLE_SEQ_MEDIA
extMediaStream.Position +=
pcmInfo.ConvertTimeToBytes(extMedia.ClipBegin.AsLocalUnits);
long manMediaStreamPosBefore = manMediaStream.Position;
long extMediaStreamPosBefore = extMediaStream.Position;
//DebugFix.Assert(AudioLibPCMFormat.CompareStreamData(manMediaStream, extMediaStream, (int)manMediaStream.Length));
//DebugFix.Assert(manMediaStream.Position == manMediaStreamPosBefore + manMediaStream.Length);
//DebugFix.Assert(extMediaStream.Position == extMediaStreamPosBefore + manMediaStream.Length);
}
finally
{
extMediaStream.Close();
manMediaStream.Close();
}
}
}
else
{
DebugFix.Assert(manSeqMedia == null);
}
}
else
{
DebugFix.Assert(manSeqMedia == null);
}
foreach (TreeNode child in node.Children.ContentsAs_Enumerable)
{
verifyTree(child, ancestorHasAudio, ancestorExtAudioFile);
}
}
public static string ConvertedFile(string filePath, Presentation pres)
{
AudioLib.WavFormatConverter audioConverter = new WavFormatConverter(true, true);
int samplingRate = (int)pres.MediaDataManager.DefaultPCMFormat.Data.SampleRate;
int channels = pres.MediaDataManager.DefaultPCMFormat.Data.NumberOfChannels;
int bitDepth = pres.MediaDataManager.DefaultPCMFormat.Data.BitDepth;
string directoryPath = pres.DataProviderManager.DataFileDirectoryFullPath;
string convertedFile = null;
try
{
if (Path.GetExtension(filePath).ToLower() == ".wav")
{
Stream wavStream = null;
wavStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
uint dataLength;
AudioLibPCMFormat newFilePCMInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
if (wavStream != null)
{
wavStream.Close();
}
if (newFilePCMInfo.SampleRate == samplingRate && newFilePCMInfo.NumberOfChannels == channels && newFilePCMInfo.BitDepth == bitDepth)
{
convertedFile = filePath;
}
else
{
AudioLibPCMFormat pcmFormat = new AudioLibPCMFormat((ushort)channels, (uint)samplingRate, (ushort)bitDepth);
AudioLibPCMFormat originalPCMFormat = null;
convertedFile = audioConverter.ConvertSampleRate(filePath, directoryPath, pcmFormat, out originalPCMFormat);
}
}
else if (Path.GetExtension(filePath).ToLower() == ".mp3")
{
AudioLibPCMFormat pcmFormat = new AudioLibPCMFormat((ushort)channels, (uint)samplingRate, (ushort)bitDepth);
AudioLibPCMFormat originalPCMFormat = null;
convertedFile = audioConverter.UnCompressMp3File(filePath, directoryPath, pcmFormat, out originalPCMFormat);
}
else if (Path.GetExtension(filePath).ToLower() == ".mp4" || Path.GetExtension(filePath).ToLower() == ".m4a")
{
AudioLibPCMFormat pcmFormat = new AudioLibPCMFormat((ushort)channels, (uint)samplingRate, (ushort)bitDepth);
AudioLibPCMFormat originalPCMFormat = null;
convertedFile = audioConverter.UnCompressMp4_AACFile(filePath, directoryPath, pcmFormat, out originalPCMFormat);
}
else
{
MessageBox.Show(string.Format(Localizer.Message("AudioFormatConverter_Error_FileExtentionNodSupported"), filePath), Localizer.Message("Caption_Error"));
return(null);
}
// rename converted file to original file if names are different
if (Path.GetFileName(filePath) != Path.GetFileName(convertedFile))
{
string newConvertedFilePath = Path.Combine(Path.GetDirectoryName(convertedFile), Path.GetFileNameWithoutExtension(filePath) + ".wav");
for (int i = 0; i < 99999 && File.Exists(newConvertedFilePath); i++)
{
newConvertedFilePath = Path.Combine(Path.GetDirectoryName(convertedFile), i.ToString() + Path.GetFileNameWithoutExtension(filePath) + ".wav");
if (!File.Exists(newConvertedFilePath))
{
MessageBox.Show(string.Format(Localizer.Message("Import_AudioFormat_RenameFile"), Path.GetFileNameWithoutExtension(filePath) + ".wav", Path.GetFileName(newConvertedFilePath)),
Localizer.Message("Caption_Information"),
MessageBoxButtons.OK);
break;
}
}
File.Move(convertedFile, newConvertedFilePath);
convertedFile = newConvertedFilePath;
}
}
catch (System.Exception ex)
{
MessageBox.Show(ex.ToString());
return(null);
}
return(convertedFile);
}
private static void CheckPublishedFiles(TreeNode node, Channel sourceCh, Channel destCh,
Uri curWavUri_, MemoryStream curAudioData, PCMFormatInfo curPCMFormat)
{
Uri curWavUri = (curWavUri_ == null ? null : new Uri(curWavUri_.ToString()));
if (node.HasProperties(typeof(ChannelsProperty)))
{
ChannelsProperty chProp = node.GetProperty <ChannelsProperty>();
ManagedAudioMedia mam = chProp.GetMedia(sourceCh) as ManagedAudioMedia;
ExternalAudioMedia eam = chProp.GetMedia(destCh) as ExternalAudioMedia;
Assert.AreEqual(mam == null, eam == null,
"There may be external audio media if and only if there is managed audio media");
if (mam != null && eam != null)
{
Assert.IsTrue(mam.Duration.IsEqualTo(eam.Duration),
"Duration of managed and external audio media differs");
if (eam.Uri != null)
{
FileStream wavFS_ = new FileStream(eam.Uri.LocalPath, FileMode.Open, FileAccess.Read, FileShare.None);
Stream manAudioStream = mam.AudioMediaData.OpenPcmInputStream();
try
{
uint dataLength;
AudioLibPCMFormat pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavFS_, out dataLength);
Assert.IsTrue(pcmInfo.IsCompatibleWith(mam.AudioMediaData.PCMFormat.Data),
"External audio has incompatible pcm format");
wavFS_.Position += pcmInfo.ConvertTimeToBytes(eam.ClipBegin.TimeAsMillisecondFloat);
Assert.IsTrue(
AudioLibPCMFormat.CompareStreamData(manAudioStream, wavFS_, (int)manAudioStream.Length),
"External audio contains wrong data");
}
finally
{
wavFS_.Close();
manAudioStream.Close();
}
}
if (curWavUri != null)
{
FileStream wavFS = new FileStream(curWavUri.LocalPath, FileMode.Open, FileAccess.Read,
FileShare.None);
try
{
uint dataLength;
AudioLibPCMFormat pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavFS, out dataLength);
Assert.IsTrue(pcmInfo.IsCompatibleWith(curPCMFormat.Data),
"External audio has incompatible pcm format");
curAudioData.Position = 0;
Assert.AreEqual(curAudioData.Length, (long)dataLength,
"External audio has unexpected length");
Assert.IsTrue(
AudioLibPCMFormat.CompareStreamData(curAudioData, wavFS, (int)curAudioData.Length),
"External audio contains wrong data");
}
finally
{
wavFS.Close();
}
}
if (curWavUri == null)
{
curWavUri = new Uri(eam.Uri.ToString());
curAudioData = new MemoryStream();
curPCMFormat = mam.AudioMediaData.PCMFormat;
}
else if (curWavUri.ToString() != eam.Uri.ToString())
{
curWavUri = new Uri(eam.Uri.ToString());
curAudioData = new MemoryStream();
curPCMFormat = mam.AudioMediaData.PCMFormat;
}
Assert.IsTrue(curPCMFormat.ValueEquals(mam.AudioMediaData.PCMFormat),
"Managed audio has incompatible pcm format");
Stream manAudio = mam.AudioMediaData.OpenPcmInputStream();
try
{
media.data.StreamUtils.CopyData(manAudio, curAudioData);
}
finally
{
manAudio.Close();
}
}
}
foreach (TreeNode child in node.Children.ContentsAs_YieldEnumerable)
{
CheckPublishedFiles(child, sourceCh, destCh, curWavUri, curAudioData, curPCMFormat);
}
}
private void addAudio(TreeNode treeNode, XmlNode xmlNode, bool isSequence, string fullSmilPath)
{
string dirPath = Path.GetDirectoryName(fullSmilPath);
XmlAttributeCollection audioAttrs = xmlNode.Attributes;
if (audioAttrs == null || audioAttrs.Count == 0)
{
return;
}
XmlNode audioAttrSrc = audioAttrs.GetNamedItem("src");
if (audioAttrSrc == null || String.IsNullOrEmpty(audioAttrSrc.Value))
{
return;
}
XmlNode audioAttrClipBegin = audioAttrs.GetNamedItem("clipBegin");
XmlNode audioAttrClipEnd = audioAttrs.GetNamedItem("clipEnd");
Presentation presentation = m_Project.Presentations.Get(0);
Media media = null;
if (audioAttrSrc.Value.EndsWith("wav"))
{
string dirPathBook = Path.GetDirectoryName(m_Book_FilePath);
FileDataProvider dataProv = null;
string fullWavPathOriginal = Path.Combine(dirPathBook, audioAttrSrc.Value);
if (!File.Exists(fullWavPathOriginal))
{
System.Diagnostics.Debug.Fail("File not found: {0}", fullWavPathOriginal);
media = null;
}
else
{
//bool deleteSrcAfterCompletion = false;
string fullWavPath = fullWavPathOriginal;
uint dataLength;
AudioLibPCMFormat pcmInfo = null;
if (m_OriginalAudioFile_FileDataProviderMap.ContainsKey(fullWavPath))
{
dataProv = m_OriginalAudioFile_FileDataProviderMap[fullWavPath];
}
else // create FileDataProvider
{
Stream wavStream = null;
try
{
wavStream = File.Open(fullWavPath, FileMode.Open, FileAccess.Read, FileShare.Read);
pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
//if (m_firstTimePCMFormat)
//{
// presentation.MediaDataManager.DefaultPCMFormat = new PCMFormatInfo(pcmInfo);
// m_firstTimePCMFormat = false;
//}
if (!presentation.MediaDataManager.DefaultPCMFormat.Data.IsCompatibleWith(pcmInfo))
{
wavStream.Close();
wavStream = null;
string newfullWavPath = m_AudioConversionSession.ConvertAudioFileFormat(fullWavPath);
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
Console.WriteLine("Source audio file to SDK audio file map (before creating SDK audio file): " + Path.GetFileName(fullWavPath) + " = " + dataProv.DataFileRelativePath);
dataProv.InitByMovingExistingFile(newfullWavPath);
m_OriginalAudioFile_FileDataProviderMap.Add(fullWavPath, dataProv);
}
else // use original wav file by copying it to data directory
{
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
Console.WriteLine("Source audio file to SDK audio file map (before creating SDK audio file): " + Path.GetFileName(fullWavPath) + " = " + dataProv.DataFileRelativePath);
dataProv.InitByCopyingExistingFile(fullWavPath);
m_OriginalAudioFile_FileDataProviderMap.Add(fullWavPath, dataProv);
}
}
finally
{
if (wavStream != null)
{
wavStream.Close();
}
}
}
} // FileDataProvider key check ends
media = addAudioWav(dataProv, audioAttrClipBegin, audioAttrClipEnd);
//media = addAudioWav ( fullWavPath, deleteSrcAfterCompletion, audioAttrClipBegin, audioAttrClipEnd );
}
else if (audioAttrSrc.Value.EndsWith("mp3"))
{
string fullMp3PathOriginal = Path.Combine(dirPath, audioAttrSrc.Value);
if (!File.Exists(fullMp3PathOriginal))
{
System.Diagnostics.Debug.Fail("File not found: {0}", fullMp3PathOriginal);
return;
}
string newfullWavPath = m_AudioConversionSession.ConvertAudioFileFormat(fullMp3PathOriginal);
FileDataProvider dataProv = null;
if (m_OriginalAudioFile_FileDataProviderMap.ContainsKey(fullMp3PathOriginal))
{
dataProv = m_OriginalAudioFile_FileDataProviderMap[fullMp3PathOriginal];
}
else
{
dataProv = (FileDataProvider)presentation.DataProviderFactory.Create(DataProviderFactory.AUDIO_WAV_MIME_TYPE);
Console.WriteLine("Source audio file to SDK audio file map (before creating SDK audio file): " + Path.GetFileName(fullMp3PathOriginal) + " = " + dataProv.DataFileRelativePath);
dataProv.InitByMovingExistingFile(newfullWavPath);
m_OriginalAudioFile_FileDataProviderMap.Add(fullMp3PathOriginal, dataProv);
}
if (newfullWavPath != null)
{
//if (m_firstTimePCMFormat)
//{
// Stream wavStream = null;
// try
// {
// wavStream = File.Open(newfullWavPath, FileMode.Open, FileAccess.Read, FileShare.Read);
// uint dataLength;
// AudioLibPCMFormat pcmInfo = null;
// pcmInfo = AudioLibPCMFormat.RiffHeaderParse(wavStream, out dataLength);
// presentation.MediaDataManager.DefaultPCMFormat = new PCMFormatInfo(pcmInfo);
// }
// finally
// {
// if (wavStream != null) wavStream.Close();
// m_firstTimePCMFormat = false;
// }
//}
//media = addAudioWav(newfullWavPath, true, audioAttrClipBegin, audioAttrClipEnd);
media = addAudioWav(dataProv, audioAttrClipBegin, audioAttrClipEnd);
}
//}
}
if (media == null)
{
media = presentation.MediaFactory.CreateExternalAudioMedia();
((ExternalAudioMedia)media).Src = audioAttrSrc.Value;
if (audioAttrClipBegin != null &&
!string.IsNullOrEmpty(audioAttrClipBegin.Value))
{
try
{
((ExternalAudioMedia)media).ClipBegin =
Time.ParseTimeString(audioAttrClipBegin.Value);
}
catch (FormatException e)
{
((ExternalAudioMedia)media).ClipBegin =
new Time(0);
string str = "bad time string: " + audioAttrClipBegin.Value;
Console.Write(str);
Debug.Fail(str);
}
}
if (audioAttrClipEnd != null &&
!string.IsNullOrEmpty(audioAttrClipEnd.Value))
{
try
{
((ExternalAudioMedia)media).ClipEnd =
Time.ParseTimeString(audioAttrClipEnd.Value);
}
catch (FormatException e)
{
((ExternalAudioMedia)media).ClipEnd =
new Time(0);
string str = "bad time string: " + audioAttrClipEnd.Value;
Console.Write(str);
Debug.Fail(str);
}
}
}
if (media != null)
{
ChannelsProperty chProp =
treeNode.GetProperty <ChannelsProperty>();
if (chProp == null)
{
chProp =
presentation.PropertyFactory.CreateChannelsProperty();
treeNode.AddProperty(chProp);
}
if (isSequence)
{
SequenceMedia mediaSeq = chProp.GetMedia(m_audioChannel) as SequenceMedia;
if (mediaSeq == null)
{
mediaSeq = presentation.MediaFactory.CreateSequenceMedia();
mediaSeq.AllowMultipleTypes = false;
chProp.SetMedia(m_audioChannel, mediaSeq);
}
mediaSeq.ChildMedias.Insert(mediaSeq.ChildMedias.Count, media);
}
else
{
chProp.SetMedia(m_audioChannel, media);
}
}
else
{
System.Diagnostics.Debug.Fail("Media could not be created !");
}
}