/// <summary>
/// Generate the ScriptF0Contour object from the xml doc indicated by reader.
/// </summary>
/// <param name="reader">Xml text reader.</param>
public void ParseFromXml(XmlTextReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
string encoding = reader.GetAttribute("type");
_chunkEncoding = ScriptAcousticChunk.StringToChunkEncoding(encoding);
if (!reader.IsEmptyElement)
{
if (reader.Read())
{
_contour = ScriptAcousticChunk.ParseFromXml(reader, _chunkEncoding);
}
}
}
/// <summary>
/// Get the F0s in the state.
/// </summary>
/// <param name="utt">Utterance which will provide the F0 values.</param>
/// <param name="f0StartIndex">The start index to get the F0.</param>
/// <param name="duration">The duration value in the state.</param>
/// <param name="f0EncodingMode">The F0 encoding mode, like "text", "hexBinary", etc.</param>
/// <param name="relativeBegin">The begin position of the voice segment.</param>
/// <param name="relativeEnd">The end position of the voice segment.</param>
/// <param name="reBeginPositionFindOut">The bool value to mark if arrive the first voice segment.</param>
/// <param name="isF0ValueExist">The bool value to mark if the F0 value exist, means not all equal to 0.</param>
/// <returns>Object ScriptUvSeg.</returns>
private static ScriptUvSeg GetF0Contour(SP.TtsUtterance utt, int f0StartIndex,
int duration, ScriptAcousticChunkEncoding f0EncodingMode, ref int relativeBegin,
ref int relativeEnd, ref bool reBeginPositionFindOut, ref bool isF0ValueExist)
{
Debug.Assert(utt != null, "Utt should not be null");
Debug.Assert(f0StartIndex >= 0, "f0StartIndex should not be less than 0");
Debug.Assert(duration > 0, "Duration should not be less than 0");
Debug.Assert(relativeBegin >= 0, "relativeBegin should not be less than 0");
Debug.Assert(relativeEnd >= 0, "relativeEnd should not be less than 0");
ScriptUvSeg scriptUvSeg = new ScriptUvSeg();
scriptUvSeg.SegType = ScriptUvSegType.Mixed;
scriptUvSeg.F0Contour = new ScriptF0Contour();
scriptUvSeg.F0Contour.ChunkEncoding = f0EncodingMode;
int f0EndIndex = f0StartIndex + duration;
for (int i = f0StartIndex; i < f0EndIndex; i++)
{
float f0 = utt.Acoustic.F0s[i][0];
if (f0 == 0)
{
if (reBeginPositionFindOut == false)
{
relativeBegin++;
relativeEnd++;
}
}
else
{
isF0ValueExist = true;
reBeginPositionFindOut = true;
relativeEnd++;
scriptUvSeg.F0Contour.Contour.Add(f0);
}
}
return scriptUvSeg;
}
/// <summary>
/// Initializes a new instance of the <see cref="ScriptF0Contour"/> class.
/// </summary>
/// <param name="name">Name of the contour.</param>
public ScriptF0Contour(string name = DefaultName)
{
_chunkEncoding = ScriptAcousticChunkEncoding.Unknown;
_contour = new Collection<float>();
Name = name;
}
/// <summary>
/// Initializes a new instance of the <see cref="ScriptF0Contour"/> class.
/// </summary>
/// <param name="chunkEncoding">Encoding of the chunk.</param>
/// <param name="contour">Contour.</param>
/// <param name="name">Name of the contour.</param>
public ScriptF0Contour(ScriptAcousticChunkEncoding chunkEncoding, Collection<float> contour, string name = DefaultName)
{
if (chunkEncoding == ScriptAcousticChunkEncoding.Unknown)
{
throw new ArgumentOutOfRangeException("chunkEncoding", "can't be ScriptAcousticChunkEncoding.Unknown");
}
else if (contour == null)
{
throw new ArgumentNullException("contour");
}
_chunkEncoding = chunkEncoding;
_contour = contour;
Name = name;
}
/// <summary>
/// Write binary chunk data according to encoding type to xml script.
/// </summary>
/// <param name="writer">Xml writer.</param>
/// <param name="chunkEncoding">Encoding of the chunk.</param>
/// <param name="chunkData">Chunk data.</param>
private static void WriteBinaryData(XmlWriter writer, ScriptAcousticChunkEncoding chunkEncoding,
Collection<float> chunkData)
{
Debug.Assert(writer != null);
Debug.Assert(chunkEncoding == ScriptAcousticChunkEncoding.Base64Binary ||
chunkEncoding == ScriptAcousticChunkEncoding.HexBinary);
int bufSize = chunkData.Count * sizeof(float);
byte[] bytes = new byte[bufSize];
int bytesIndex = 0;
for (int i = 0; i < chunkData.Count; i++)
{
byte[] floatBytes = BitConverter.GetBytes(chunkData[i]);
for (int j = 0; j < sizeof(float); j++)
{
bytes[bytesIndex] = floatBytes[j];
bytesIndex ++;
}
}
switch (chunkEncoding)
{
case ScriptAcousticChunkEncoding.Base64Binary:
writer.WriteBase64(bytes, 0, bufSize);
break;
case ScriptAcousticChunkEncoding.HexBinary:
writer.WriteBinHex(bytes, 0, bufSize);
break;
}
}
/// <summary>
/// Parse binary chunk data according to encoding type from the xml doc indicated by reader.
/// </summary>
/// <param name="reader">Xml text reader.</param>
/// <param name="chunkEncoding">Encoding of the chunk.</param>
/// <param name="chunkData">Chunk data.</param>
private static void ParseBinaryData(XmlTextReader reader, ScriptAcousticChunkEncoding chunkEncoding,
Collection<float> chunkData)
{
Debug.Assert(reader != null);
Debug.Assert(chunkEncoding == ScriptAcousticChunkEncoding.Base64Binary ||
chunkEncoding == ScriptAcousticChunkEncoding.HexBinary);
Debug.Assert(reader.NodeType == XmlNodeType.Text);
const int FloatCount = 200;
int bufSize = sizeof(float) * FloatCount;
byte[] bytes = new byte[bufSize];
while (reader.NodeType == XmlNodeType.Text)
{
int len = 0;
switch (chunkEncoding)
{
case ScriptAcousticChunkEncoding.Base64Binary:
len = reader.ReadContentAsBase64(bytes, 0, bufSize);
break;
case ScriptAcousticChunkEncoding.HexBinary:
len = reader.ReadContentAsBinHex(bytes, 0, bufSize);
break;
}
if ((len % sizeof(float)) != 0)
{
string message = string.Format(CultureInfo.InvariantCulture,
"Size of binary chunk data isn't multiple of sizeof(float).");
throw new InvalidDataException(message);
}
for (int i = 0; i < len; i += sizeof(float))
{
chunkData.Add(BitConverter.ToSingle(bytes, i));
}
}
Debug.Assert(reader.NodeType == XmlNodeType.EndElement);
}
/// <summary>
/// Write the acoustic chunk data to xml script.
/// </summary>
/// <param name="writer">Xml writer.</param>
/// <param name="chunkEncoding">Encoding of the chunk.</param>
/// <param name="chunkData">Chunk data.</param>
public static void WriteToXml(XmlWriter writer, ScriptAcousticChunkEncoding chunkEncoding,
Collection<float> chunkData)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (chunkEncoding == ScriptAcousticChunkEncoding.Unknown)
{
throw new ArgumentOutOfRangeException("chunkEncoding", "can't be unknown");
}
switch (chunkEncoding)
{
case ScriptAcousticChunkEncoding.Text:
WriteTextData(writer, chunkData);
break;
case ScriptAcousticChunkEncoding.Base64Binary:
WriteBase64BinaryData(writer, chunkData);
break;
case ScriptAcousticChunkEncoding.HexBinary:
WriteHexBinaryData(writer, chunkData);
break;
}
}
/// <summary>
/// Get chunk type and chunk data from the xml doc indicated by reader.
/// </summary>
/// <param name="reader">Xml text reader.</param>
/// <param name="chunkEncoding">Encoding of the chunk.</param>
/// <returns>Chunk data parsed from xml script.</returns>
public static Collection<float> ParseFromXml(XmlTextReader reader, ScriptAcousticChunkEncoding chunkEncoding)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (chunkEncoding == ScriptAcousticChunkEncoding.Unknown)
{
throw new ArgumentOutOfRangeException("chunkEncoding", "can't be unknown");
}
if (reader.NodeType != XmlNodeType.Text)
{
throw new InvalidDataException("Text node is expected at ScriptAcousticChunk parsing beginning.");
}
Collection<float> chunkData = new Collection<float>();
switch (chunkEncoding)
{
case ScriptAcousticChunkEncoding.Text:
ParseTextData(reader, chunkData);
break;
case ScriptAcousticChunkEncoding.Base64Binary:
ParseBase64BinaryData(reader, chunkData);
break;
case ScriptAcousticChunkEncoding.HexBinary:
ParseHexBinaryData(reader, chunkData);
break;
}
if (reader.NodeType != XmlNodeType.EndElement)
{
throw new InvalidDataException("EndElement is expected at ScriptAcousticChunk parsing end.");
}
return chunkData;
}
/// <summary>
/// Convert chunk encoding from enum type to string type.
/// </summary>
/// <param name="chunkEncoding">Enum type of the chunk encoding.</param>
/// <returns>String type of the chunk encoding.</returns>
public static string ChunkEncodingToString(ScriptAcousticChunkEncoding chunkEncoding)
{
string type;
switch (chunkEncoding)
{
case ScriptAcousticChunkEncoding.Unknown:
default:
type = "unknown";
break;
case ScriptAcousticChunkEncoding.Text:
type = "text";
break;
case ScriptAcousticChunkEncoding.Base64Binary:
type = "base64Binary";
break;
case ScriptAcousticChunkEncoding.HexBinary:
type = "hexBinary";
break;
}
return type;
}
