/// <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); }
/// <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); } }
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); } }
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); } }