private Dictionary <string, FileDataProvider> m_OriginalAudioFile_FileDataProviderMap = new Dictionary <string, FileDataProvider>(); // maps original audio file refered by smil to FileDataProvider of sdk.
//private bool m_firstTimePCMFormat;
//private Dictionary<string, string> m_convertedWavFiles = null;
//private Dictionary<string, string> m_convertedMp3Files = null;
private void parseSmiles(List <string> spineOfSmilFiles)
{
if (spineOfSmilFiles == null || spineOfSmilFiles.Count <= 0)
{
return;
}
//m_firstTimePCMFormat = true;
m_AudioConversionSession = new AudioFormatConvertorSession(m_Project.Presentations.Get(0));
m_OriginalAudioFile_FileDataProviderMap.Clear();
string dirPath = Path.GetDirectoryName(m_Book_FilePath);
foreach (string smilPath in spineOfSmilFiles)
{
string fullSmilPath = Path.Combine(dirPath, smilPath);
Console.WriteLine("smil file to be parsed: " + Path.GetFileName(smilPath));
parseSmil(fullSmilPath);
}
//m_AudioConversionSession.DeleteSessionAudioFiles();
m_AudioConversionSession = null;
}
public DAISY202Import(string nccPath, ObiPresentation presentation, Settings settings)
{
m_NccPath = nccPath;
m_NccBaseDirectory = Path.GetDirectoryName(nccPath);
m_OpenSectionNodes = new System.Collections.Generic.Stack <Obi.SectionNode>();
m_Presentation = presentation;
m_SectionNodesToSmilReferenceMap = new Dictionary <SectionNode, string>();
m_AudioConversionSession = new AudioFormatConvertorSession(m_Presentation.DataProviderManager.DataFileDirectoryFullPath,
m_Presentation.MediaDataManager.DefaultPCMFormat,
false,
false);
m_Settings = settings;
m_Counter_FrontPageCorection = 0;
}
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);
}
}
protected override void parseContentDocuments(List <string> spineOfContentDocuments,
Dictionary <string, string> spineAttributes,
List <Dictionary <string, string> > spineItemsAttributes,
string coverImagePath, string navDocPath)
{
if (spineOfContentDocuments == null || spineOfContentDocuments.Count <= 0)
{
return;
}
// assign obi project file path to xuk path to prevent creation of xukspine file.
XukPath = m_session.Path;
//Console.WriteLine(XukPath);
Presentation spinePresentation = m_Project.Presentations.Get(0);
m_IsTOCFromNavDoc = false;
if (navDocPath != null)
{
string fullNavPath = Path.Combine(Path.GetDirectoryName(m_Book_FilePath), navDocPath);
XmlDocument navDoc = urakawa.xuk.XmlReaderWriterHelper.ParseXmlDocument(fullNavPath, true, true);
ParseNCXDocument(navDoc);
m_IsTOCFromNavDoc = true;
}
//spinePresentation.RootNode.GetOrCreateXmlProperty().SetQName("spine", "");
//if (!string.IsNullOrEmpty(m_OPF_ContainerRelativePath))
//{
//spinePresentation.RootNode.GetOrCreateXmlProperty().SetAttribute(OPF_ContainerRelativePath, "", m_OPF_ContainerRelativePath);
//}
//foreach (KeyValuePair<string, string> spineAttribute in spineAttributes)
//{
//spinePresentation.RootNode.GetOrCreateXmlProperty().SetAttribute(spineAttribute.Key, "", spineAttribute.Value);
//}
//if (m_PackagePrefixAttr != null)
//{
//spinePresentation.RootNode.GetOrCreateXmlProperty().SetAttribute("prefix", "", m_PackagePrefixAttr.Value);
//}
// Audio files may be shared between chapters of a book!
m_OriginalAudioFile_FileDataProviderMap.Clear();
TreenodesWithoutManagedAudioMediaData = new List <TreeNode>();
Presentation spineItemPresentation = null;
int index = -1;
foreach (string docPath in spineOfContentDocuments)
{
index++;
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.ReadXMLDoc, docPath));
//System.Windows.Forms.MessageBox.Show(docPath);
//DirectoryInfo opfParentDir = Directory.GetParent(m_Book_FilePath);
//string dirPath = opfParentDir.ToString();
string fullDocPath = Path.Combine(Path.GetDirectoryName(m_Book_FilePath), docPath);
fullDocPath = FileDataProvider.NormaliseFullFilePath(fullDocPath).Replace('/', '\\');
if (!File.Exists(fullDocPath))
{
#if DEBUG
Debugger.Break();
#endif //DEBUG
continue;
}
addOPF_GlobalAssetPath(fullDocPath);
///TreeNode spineChild = spinePresentation.TreeNodeFactory.Create();
//TextMedia txt = spinePresentation.MediaFactory.CreateTextMedia();
//txt.Text = docPath; // Path.GetFileName(fullDocPath);
//spineChild.GetOrCreateChannelsProperty().SetMedia(spinePresentation.ChannelsManager.GetOrCreateTextChannel(), txt);
//spinePresentation.RootNode.AppendChild(spineChild);
//spineChild.GetOrCreateXmlProperty().SetQName("metadata", "");
//foreach (KeyValuePair<string, string> spineItemAttribute in spineItemsAttributes[index])
//{
//spineChild.GetOrCreateXmlProperty().SetAttribute(spineItemAttribute.Key, "", spineItemAttribute.Value);
//}
string ext = Path.GetExtension(fullDocPath);
if (docPath == coverImagePath)
{
DebugFix.Assert(ext.Equals(DataProviderFactory.IMAGE_SVG_EXTENSION, StringComparison.OrdinalIgnoreCase));
//spineChild.GetOrCreateXmlProperty().SetAttribute("cover-image", "", "true");
}
if (docPath == navDocPath)
{
DebugFix.Assert(
ext.Equals(DataProviderFactory.XHTML_EXTENSION, StringComparison.OrdinalIgnoreCase) ||
ext.Equals(DataProviderFactory.HTML_EXTENSION, StringComparison.OrdinalIgnoreCase));
//spineChild.GetOrCreateXmlProperty().SetAttribute("nav", "", "true");
}
if (
!ext.Equals(DataProviderFactory.XHTML_EXTENSION, StringComparison.OrdinalIgnoreCase) &&
!ext.Equals(DataProviderFactory.HTML_EXTENSION, StringComparison.OrdinalIgnoreCase) &&
!ext.Equals(DataProviderFactory.DTBOOK_EXTENSION, StringComparison.OrdinalIgnoreCase) &&
!ext.Equals(DataProviderFactory.XML_EXTENSION, StringComparison.OrdinalIgnoreCase)
)
{
DebugFix.Assert(ext.Equals(DataProviderFactory.IMAGE_SVG_EXTENSION, StringComparison.OrdinalIgnoreCase));
bool notExistYet = true;
foreach (ExternalFileData externalFileData in m_Project.Presentations.Get(0).ExternalFilesDataManager.ManagedObjects.ContentsAs_Enumerable)
{
if (!string.IsNullOrEmpty(externalFileData.OriginalRelativePath))
{
bool notExist = docPath != externalFileData.OriginalRelativePath;
notExistYet = notExistYet && notExist;
if (!notExist)
{
break;
}
}
}
DebugFix.Assert(notExistYet);
if (notExistYet)
{
ExternalFileData externalData = null;
if (docPath == coverImagePath)
{
externalData = m_Project.Presentations.Get(0).ExternalFilesDataFactory.Create
<CoverImageExternalFileData>();
}
else
{
externalData = m_Project.Presentations.Get(0).ExternalFilesDataFactory.Create
<GenericExternalFileData>();
}
if (externalData != null)
{
externalData.InitializeWithData(fullDocPath, docPath, true, null);
addOPF_GlobalAssetPath(fullDocPath);
}
}
continue;
}
//spineChild.GetOrCreateXmlProperty().SetAttribute("xuk", "", "true");
XmlDocument xmlDoc = urakawa.xuk.XmlReaderWriterHelper.ParseXmlDocument(fullDocPath, true, true);
if (RequestCancellation)
{
return;
}
///m_PublicationUniqueIdentifier = null;
//m_PublicationUniqueIdentifierNode = null;
//Project spineItemProject = new Project();
//spineItemProject.PrettyFormat = m_XukPrettyFormat;
//string dataFolderPrefix = FileDataProvider.EliminateForbiddenFileNameCharacters(docPath);
//spineItemPresentation = spineItemProject.AddNewPresentation(new Uri(m_outDirectory),
//dataFolderPrefix
//);
//PCMFormatInfo pcmFormat = spineItemPresentation.MediaDataManager.DefaultPCMFormat; //.Copy();
//pcmFormat.Data.SampleRate = (ushort)m_audioProjectSampleRate;
//pcmFormat.Data.NumberOfChannels = m_audioStereo ? (ushort)2 : (ushort)1;
//spineItemPresentation.MediaDataManager.DefaultPCMFormat = pcmFormat;
//TextChannel textChannel = spineItemPresentation.ChannelFactory.CreateTextChannel();
//textChannel.Name = "The Text Channel";
//DebugFix.Assert(textChannel == spineItemPresentation.ChannelsManager.GetOrCreateTextChannel());
//AudioChannel audioChannel = spineItemPresentation.ChannelFactory.CreateAudioChannel();
//audioChannel.Name = "The Audio Channel";
//DebugFix.Assert(audioChannel == spineItemPresentation.ChannelsManager.GetOrCreateAudioChannel());
//ImageChannel imageChannel = spineItemPresentation.ChannelFactory.CreateImageChannel();
//imageChannel.Name = "The Image Channel";
//DebugFix.Assert(imageChannel == spineItemPresentation.ChannelsManager.GetOrCreateImageChannel());
//VideoChannel videoChannel = spineItemPresentation.ChannelFactory.CreateVideoChannel();
//videoChannel.Name = "The Video Channel";
//DebugFix.Assert(videoChannel == spineItemPresentation.ChannelsManager.GetOrCreateVideoChannel());
if (m_AudioConversionSession != null)
{
RemoveSubCancellable(m_AudioConversionSession);
m_AudioConversionSession = null;
}
m_AudioConversionSession = new AudioFormatConvertorSession(
m_Presentation.DataProviderManager.DataFileDirectoryFullPath,
m_Presentation.MediaDataManager.DefaultPCMFormat,
m_autoDetectPcmFormat,
true);
//AddSubCancellable(m_AudioConversionSession);
if (RequestCancellation)
{
return;
}
if (parseContentDocParts(fullDocPath, m_Project, xmlDoc, docPath, DocumentMarkupType.NA))
{
return; // user cancel
}
/*
* string title = GetTitle(spineItemPresentation);
* if (!string.IsNullOrEmpty(title))
* {
* spineChild.GetOrCreateXmlProperty().SetAttribute("title", "", title);
* }
*
*
* if (false) // do not copy metadata from project to individual chapter
* {
* foreach (Metadata metadata in m_Project.Presentations.Get(0).Metadatas.ContentsAs_Enumerable)
* {
* Metadata md = spineItemPresentation.MetadataFactory.CreateMetadata();
* md.NameContentAttribute = metadata.NameContentAttribute.Copy();
*
* foreach (MetadataAttribute metadataAttribute in metadata.OtherAttributes.ContentsAs_Enumerable)
* {
* MetadataAttribute mdAttr = metadataAttribute.Copy();
* md.OtherAttributes.Insert(md.OtherAttributes.Count, mdAttr);
* }
*
* spineItemPresentation.Metadatas.Insert(spineItemPresentation.Metadatas.Count, md);
* }
* }
*/
foreach (KeyValuePair <string, string> spineItemAttribute in spineItemsAttributes[index])
{
if (spineItemAttribute.Key == "media-overlay")
{
string opfDirPath = Path.GetDirectoryName(m_Book_FilePath);
string overlayPath = spineItemAttribute.Value;
reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.ParsingMediaOverlay, overlayPath));
string fullOverlayPath = Path.Combine(opfDirPath, overlayPath);
if (!File.Exists(fullOverlayPath))
{
continue;
}
XmlDocument overlayXmlDoc = XmlReaderWriterHelper.ParseXmlDocument(fullOverlayPath, false, false);
SectionNode section = m_Presentation.FirstSection;
IEnumerable <XmlNode> textElements = XmlDocumentHelper.GetChildrenElementsOrSelfWithName(overlayXmlDoc, true, "text", null, false);
if (textElements == null)
{
continue;
}
// audio list replaced by text list
//IEnumerable<XmlNode> audioElements = XmlDocumentHelper.GetChildrenElementsOrSelfWithName(overlayXmlDoc, true, "audio", null, false);
//if (audioElements == null)
//{
//continue;
//}
//foreach (XmlNode audioNode in audioElements)
foreach (XmlNode textNode in textElements)
{
XmlAttributeCollection attrs = textNode.Attributes;
if (attrs == null)
{
continue;
}
//XmlAttributeCollection attrs = audioNode.Attributes;
//if (attrs == null)
//{
//continue;
//}
XmlNode attrSrc = attrs.GetNamedItem("src");
if (attrSrc == null)
{
continue;
}
//XmlNode attrBegin = attrs.GetNamedItem("clipBegin");
//XmlNode attrEnd = attrs.GetNamedItem("clipEnd");
//string overlayDirPath = Path.GetDirectoryName(fullOverlayPath);
//string fullAudioPath = Path.Combine(overlayDirPath, attrSrc.Value);
//if (!File.Exists(fullAudioPath))
//{
// continue;
//}
//if (RequestCancellation) return;
//reportProgress(-1, String.Format(UrakawaSDK_daisy_Lang.DecodingAudio, Path.GetFileName(fullAudioPath)));
TreeNode textTreeNode = null;
XmlNode audioNode = null;
PageNumber pgNumber = null;
//XmlNodeList children = audioNode.ParentNode.ChildNodes;
XmlNodeList children = textNode.ParentNode.ChildNodes;
foreach (XmlNode child in children)
{
//if (child == audioNode)
//{
//continue;
//}
//if (child.LocalName != "text")
//{
//continue;
//}
if (child.LocalName == "audio")
{
audioNode = child;
}
//XmlAttributeCollection textAttrs = child.Attributes;
XmlAttributeCollection textAttrs = textNode.Attributes;
if (textAttrs == null)
{
continue;
}
XmlNode textSrc = textAttrs.GetNamedItem("src");
if (textSrc == null)
{
continue;
}
string urlDecoded = FileDataProvider.UriDecode(textSrc.Value);
string contentFilesDirectoryPath = Path.GetDirectoryName(fullOverlayPath);
if (urlDecoded.StartsWith("./"))
{
urlDecoded = urlDecoded.Remove(0, 2);
}
if (urlDecoded.StartsWith("../"))
{
urlDecoded = urlDecoded.Remove(0, 3);
contentFilesDirectoryPath = Path.GetDirectoryName(contentFilesDirectoryPath);
}
if (urlDecoded.IndexOf('#') > 0)
{
string[] srcParts = urlDecoded.Split('#');
if (srcParts.Length != 2)
{
continue;
}
string fullTextRefPath = Path.Combine(contentFilesDirectoryPath,
srcParts[0]);
fullTextRefPath =
FileDataProvider.NormaliseFullFilePath(fullTextRefPath).Replace('/', '\\');
if (!fullTextRefPath.Equals(fullDocPath, StringComparison.OrdinalIgnoreCase))
{
//#if DEBUG
// Debugger.Break();
//#endif //DEBUG
continue;
}
string txtId = srcParts[1];
//textTreeNode = spineItemPresentation.RootNode.GetFirstDescendantWithXmlID(txtId);
// replacing it
//System.Windows.Forms.MessageBox.Show("retrieving: " + urlDecoded);
if (m_XmlIdToSectionNodeMap.ContainsKey(urlDecoded))
{
textTreeNode = m_XmlIdToSectionNodeMap[urlDecoded];
}
else if (m_XmlIdToSectionNodeMap.ContainsKey(srcParts[0]))
{
textTreeNode = m_XmlIdToSectionNodeMap[srcParts[0]];
}
if (textTreeNode != null)
{
section = (SectionNode)textTreeNode;
//System.Windows.Forms.MessageBox.Show(((SectionNode)textTreeNode).Label);
}
}
else
{
string fullTextRefPath = Path.Combine(Path.GetDirectoryName(fullOverlayPath),
urlDecoded);
fullTextRefPath =
FileDataProvider.NormaliseFullFilePath(fullTextRefPath).Replace('/', '\\');
if (!fullTextRefPath.Equals(fullDocPath, StringComparison.OrdinalIgnoreCase))
{
//#if DEBUG
// Debugger.Break();
//#endif //DEBUG
continue;
}
textTreeNode = spineItemPresentation.RootNode;
}
if (m_XmlIdToPageNodeMap.ContainsKey(urlDecoded) &&
m_XmlIdToPageNodeMap[urlDecoded] != null)
{
EmptyNode pgNode = m_XmlIdToPageNodeMap[urlDecoded];
pgNumber = pgNode.PageNumber;
// if the section does not match then the parent of the page node should become the section.
if (pgNode.IsRooted &&
textTreeNode == null &&
pgNode.Parent != section)
{
section = pgNode.ParentAs <SectionNode>();
//Console.WriteLine("text node is null");
}
if (pgNode.IsRooted)
{
pgNode.Detach();
}
// the phrases following the page phrase in smil will refer to same content doc ID. so to avoid reassigning page, the page node in dictionary is assigned to null.
m_XmlIdToPageNodeMap[urlDecoded] = null;
}
}
if (section != null && audioNode != null)
{
PhraseNode audioWrapperNode = m_Presentation.CreatePhraseNode();
section.AppendChild(audioWrapperNode);
addAudio(audioWrapperNode, audioNode, false, fullOverlayPath);
if (audioWrapperNode.Duration == 0 && !TreenodesWithoutManagedAudioMediaData.Contains(audioWrapperNode))
{
TreenodesWithoutManagedAudioMediaData.Add(audioWrapperNode);
}
if (pgNumber != null)
{
audioWrapperNode.PageNumber = pgNumber;
pgNumber = null;
}
}
audioNode = null;
}
}
}
//spinePresentation.MediaDataManager.DefaultPCMFormat = spineItemPresentation.MediaDataManager.DefaultPCMFormat; //copied!
//string xuk_FilePath = GetXukFilePath_SpineItem(m_outDirectory, docPath, title, index);
//string xukFileName = Path.GetFileName(xuk_FilePath);
//spineChild.GetOrCreateXmlProperty().SetAttribute("xukFileName", "", xukFileName);
//deleteDataDirectoryIfEmpty();
//string dataFolderPath = spineItemPresentation.DataProviderManager.DataFileDirectoryFullPath;
//spineItemPresentation.DataProviderManager.SetCustomDataFileDirectory(Path.GetFileNameWithoutExtension(xuk_FilePath));
//string newDataFolderPath = spineItemPresentation.DataProviderManager.DataFileDirectoryFullPath;
//DebugFix.Assert(Directory.Exists(newDataFolderPath));
//if (newDataFolderPath != dataFolderPath)
{
/*
* try
* {
* if (Directory.Exists(newDataFolderPath))
* {
* FileDataProvider.TryDeleteDirectory(newDataFolderPath, false);
* }
*
* Directory.Move(dataFolderPath, newDataFolderPath);
* }
* catch (Exception ex)
* {
#if DEBUG
* Debugger.Break();
#endif // DEBUG
* Console.WriteLine(ex.Message);
* Console.WriteLine(ex.StackTrace);
*
* spineItemPresentation.DataProviderManager.SetCustomDataFileDirectory(dataFolderPrefix);
* }
*/
}
}
}
