private static Format MapFormat(format format)
{
switch (format.name)
{
case "(no format)":
return(Import.Configuration.Format.None);
case "Comma-separated list (e.g. a,b,c)":
return(Import.Configuration.Format.CommaSeparated);
case "Pipe-separated list (e.g. a|b|c)":
return(Import.Configuration.Format.PipeSeparated);
case "HTML":
return(Import.Configuration.Format.Html);
case "Path (e.g. /a/b/c)":
return(Import.Configuration.Format.Path);
case "Pipe-separated list of paths (e.g. /a/b|/e/f)":
return(Import.Configuration.Format.PipeSeparatedPaths);
case "Comma-separated list of paths (e.g. /a/b,/e/f)":
return(Import.Configuration.Format.CommaSeparatedPaths);
}
throw new ArgumentOutOfRangeException("format", format.name, "Unexpected format.");
}
//-------------------------------------------------
// load_bdf - parse and load a BDF font
//-------------------------------------------------
bool load_bdf()
{
// set the format to text
m_format = format.TEXT;
throw new emu_unimplemented();
#if false
#endif
}
public void PipeSeparatedFormat()
{
var format = new format {
name = "Pipe-separated list (e.g. a|b|c)"
};
var options = _container.Resolve <ConfigurationOptions>();
var actual = options.Format(Format.PipeSeparated);
AssertEquivalentFormat(actual, format);
}
public void CommaSeparatedPathsFormat()
{
var format = new format {
name = "Comma-separated list of paths (e.g. /a/b,/e/f)"
};
var options = _container.Resolve <ConfigurationOptions>();
var actual = options.Format(Format.CommaSeparatedPaths);
AssertEquivalentFormat(actual, format);
}
public void PathFormat()
{
var format = new format {
name = "Path (e.g. /a/b/c)"
};
var options = _container.Resolve <ConfigurationOptions>();
var actual = options.Format(Format.Path);
AssertEquivalentFormat(actual, format);
}
public void NoFormat()
{
var format = new format {
name = "(no format)"
};
var options = _container.Resolve <ConfigurationOptions>();
var actual = options.Format(Format.None);
AssertEquivalentFormat(actual, format);
}
public void HtmlFormat()
{
var format = new format {
name = "HTML"
};
var options = _container.Resolve <ConfigurationOptions>();
var actual = options.Format(Format.Html);
AssertEquivalentFormat(actual, format);
}
/// <summary>
/// takes the input content type and quertystring and determines the output type and format
/// </summary>
/// <param name="inputContentType">The input content type - e.g. text/xml</param>
/// <param name="outputContentType">The output content type - e.g text/xml</param>
/// <param name="outputFormat">The format as an enum</param>
public static void getReturnFormat(string inputContentType, ref string outputContentType, ref format outputFormat)
{
try
{
string queryFormat = QueryStringHelper.GetQueryParameterAsString("format", "").ToUpper();
if (!String.IsNullOrEmpty(queryFormat))
{
outputFormat = (format)Enum.Parse(typeof(format), queryFormat);
}
}
catch
{
outputFormat = format.UNKNOWN;
outputContentType = "";
return;
}
if (outputFormat == format.UNKNOWN)
{
switch (inputContentType.ToLower())
{
case "text/xml": outputFormat = format.XML; break;
case "application/rss xml": outputFormat = format.RSS; break;
case "application/atom xml": outputFormat = format.ATOM; break;
case "application/xml": outputFormat = format.XML; break;
case "application/json": outputFormat = format.JSON; break;
case "text/javascript": outputFormat = format.JSON; break;
case "text/html": outputFormat = format.HTML; break;
case "application/x-www-form-urlencoded": outputFormat = format.HTML; break;
default:
outputFormat = format.XML;
inputContentType = "text/xml";
break;
}
}
if (String.IsNullOrEmpty(outputContentType))
{
switch (outputFormat)
{
case format.XML: outputContentType = "text/xml"; break;
case format.JSON: outputContentType = "application/json"; break;
case format.HTML: outputContentType = "text/HTML"; break;
case format.RSS: outputContentType = "application/rss xml"; break;
case format.ATOM: outputContentType = "application/atom xml"; break;
default: outputContentType = "text/xml"; break;
}
}
}
public static Offset <WaferMap> CreateWaferMap(FlatBufferBuilder builder,
StringOffset waferidOffset = default(StringOffset),
short wafernum = 0,
StringOffset lotidOffset = default(StringOffset),
format binFormat = format.Ascii,
VectorOffset mapOffset = default(VectorOffset))
{
builder.StartObject(5);
WaferMap.AddMap(builder, mapOffset);
WaferMap.AddLotid(builder, lotidOffset);
WaferMap.AddWaferid(builder, waferidOffset);
WaferMap.AddWafernum(builder, wafernum);
WaferMap.AddBinFormat(builder, binFormat);
return(WaferMap.EndWaferMap(builder));
}
public Excel(String fileName, format FileType)
: base(fileName)
{
/*
* $cs = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=D:\\";
* $select = "SELECT * FROM D:\test.csv"
* $conn= New-Object System.Data.OleDb.OleDbConnection($cs)
* $conn.open()
* $cmd=new-object system.data.oledb.oledbcommand($select,$conn)
* $da = New-Object system.Data.OleDb.OleDbDataAdapter($cmd)
* $dt = New-Object system.Data.datatable
* [void]$da.fill($dt)
* $conn.Close()
*/
this.fileName = fileName;
String[] csHeader = new String[] {
"Provider=Microsoft.Jet.OLEDB.4.0; Data Source=",
"Provider=Microsoft.ACE.OLEDB.12.0; Data Source=",
"Provider=Microsoft.ACE.OLEDB.12.0; Data Source="
};
String[] csSource = new String[] {
fileName,
fileName,
fileName
};
String[] csFooter = new String[] {
";Mode=ReadWrite;Extended Properties='Excel 12.0 XML;HDR=YES'",
";Extended Properties='Excel 8.0'",
";Extended Properties='Text;HDR=YES;IMEX=1'"
};
int csIndex = (int)FileType;
conn = new OleDbConnection(csHeader[csIndex] + csSource[csIndex] + csFooter[csIndex]);
conn.Open();
this.DataSetName = fileName;
dbSchema = conn.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, new object[] { null, null, null, null });
}
/// <summary>
/// Сгенерировать синтезированую речь из текста
/// </summary>
/// <param name="key">ключ доступа</param>
/// <param name="text">текст для синтеза</param>
/// <param name="_format">формат получаемого файла</param>
/// <param name="lang">язык</param>
/// <param name="_speaker">голос синтеза</param>
/// <param name="_quality">качество получаемого файла</param>
/// <param name="speed">скорость речи</param>
/// <param name="_emotion">эмоция речи</param>
public static Stream Synthes(string key, string text, format _format,
speaker _speaker, quality _quality = quality.lo, double speed = 1.0,
emotion _emotion = emotion.good)
{
string getUrl = String.Format(URL + "?text={0}&format={1}&lang=ru-RU&speaker={2}&emotion={3}&quality={4}&speed={5}&key={6}",
text, _format, _speaker, _emotion, _quality, speed.ToString().Replace(',', '.'), key);
try
{
WebRequest req = WebRequest.Create(getUrl);
WebResponse resp = req.GetResponse();
Stream stream = resp.GetResponseStream();
// StreamReader sr = new System.IO.StreamReader(stream);
//StreamWriter wr = new StreamWriter(stream);
// SoundPlayer player = new SoundPlayer(stream);
// player.PlaySync();
// return true;
return(stream);
}
catch (Exception) { return(null); }
}
? GetGuildAvatarUrl(format, size) : GetAvatarUrl(format, size);
internal AIMLTagHandler GetTagHandlerU(User user, SubQuery query, Request request, Result result, XmlNode node, bool liText)
{
AIMLTagHandler tagHandlerU = getBespokeTags(user, query, request, result, node);
string nodeNameLower = StaticAIMLUtils.ToLower(node.LocalName);
AltBot targetBot = query.TargetBot;
if (Equals(null, tagHandlerU))
{
switch (nodeNameLower)
{
case "template":
case "answer": //CML
tagHandlerU = new template(targetBot, user, query, request, result, node);
break;
case "aiml":
case "cml": //CML
tagHandlerU = new aiml(targetBot, user, query, request, result, node);
break;
case "aimlexec":
case "eval":
tagHandlerU = new aimlexec(targetBot, user, query, request, result, node);
break;
case "vars":
case "root":
case "predicates": //CML
tagHandlerU = new root(targetBot, user, query, request, result, node, (() => query.TargetSettings));
break;
case "properties":
case "bots":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.GlobalSettings));
break;
case "substitutions":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.InputSubstitutions));
break;
case "topic":
case "conversation": //CML
tagHandlerU = new topic(targetBot, user, query, request, result, node);
break;
case "category":
case "conv": //CML
tagHandlerU = new category(targetBot, user, query, request, result, node);
break;
case "and":
tagHandlerU = new and(targetBot, user, query, request, result, node);
break;
case "or":
tagHandlerU = new or(targetBot, user, query, request, result, node);
break;
case "optional":
tagHandlerU = new optional(targetBot, user, query, request, result, node);
break;
case "isa":
tagHandlerU = new isa(targetBot, user, query, request, result, node);
break;
case "bot":
tagHandlerU = new bot(targetBot, user, query, request, result, node);
break;
case "condition":
case "options": //cml
tagHandlerU = new condition_aima(targetBot, user, query, request, result, node);
break;
case "li":
if (liText)
{
tagHandlerU = new liif(targetBot, user, query, request, result, node);
}
break;
case "if":
tagHandlerU = new liif(targetBot, user, query, request, result, node);
break;
case "personf":
tagHandlerU = new format(targetBot, user, query, request, result, node,
new Func <string, string>(HttpUtility.UrlEncode),
null);
break;
case "date":
tagHandlerU = new date(targetBot, user, query, request, result, node);
break;
case "formal":
tagHandlerU = new formal(targetBot, user, query, request, result, node);
break;
case "gender":
tagHandlerU = new gender(targetBot, user, query, request, result, node);
break;
case "get":
tagHandlerU = new get(targetBot, user, query, request, result, node);
break;
case "gossip":
tagHandlerU = new gossip(targetBot, user, query, request, result, node);
break;
case "get_ip":
case "id":
tagHandlerU = new id(targetBot, user, query, request, result, node);
break;
case "inputreq":
tagHandlerU = new inputreq(targetBot, user, query, request, result, node);
break;
case "request":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "input":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "justthat": // <input index="2"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 2);
break;
case "beforethat": // <input index="3"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 3);
break;
#if !(__MonoCS__)
case "javascript":
tagHandlerU = new javascript(targetBot, user, query, request, result, node);
break;
#endif
case "learn":
case "load":
case "noload": // the commented version of <load>
tagHandlerU = new learn(targetBot, user, query, request, result, node);
break;
case "lowercase":
tagHandlerU = new lowercase(targetBot, user, query, request, result, node);
break;
case "person":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "person2":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "random":
tagHandlerU = new random(targetBot, user, query, request, result, node);
break;
case "sentence":
tagHandlerU = new sentence(targetBot, user, query, request, result, node);
break;
case "set":
tagHandlerU = new set(targetBot, user, query, request, result, node);
break;
case "size":
case "getsize":
tagHandlerU = new size(targetBot, user, query, request, result, node);
break;
case "sr":
tagHandlerU = new sr(targetBot, user, query, request, result, node);
break;
case "srai_odd":
tagHandlerU = new srai_odd(targetBot, user, query, request, result, node);
break;
case "star":
tagHandlerU = new star(targetBot, user, query, request, result, node);
break;
case "system":
tagHandlerU = new system(targetBot, user, query, request, result, node);
break;
case "that": //default <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 1);
break;
case "justbeforethat": //treated as <that index="2,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "response": //treated as <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "thatstar":
tagHandlerU = new thatstar(targetBot, user, query, request, result, node);
break;
case "think":
tagHandlerU = new think(targetBot, user, query, request, result, node);
break;
case "topicstar":
tagHandlerU = new topicstar(targetBot, user, query, request, result, node);
break;
case "uppercase":
tagHandlerU = new uppercase(targetBot, user, query, request, result, node);
break;
case "version":
case "getversion":
tagHandlerU = new version(targetBot, user, query, request, result, node);
break;
case "cycsystem":
tagHandlerU = new cycsystem(targetBot, user, query, request, result, node);
break;
case "cycretract":
tagHandlerU = new cycretract(targetBot, user, query, request, result, node);
break;
case "cycassert":
tagHandlerU = new cycassert(targetBot, user, query, request, result, node);
break;
case "cycterm":
tagHandlerU = new cycterm(targetBot, user, query, request, result, node);
break;
case "cycquery":
tagHandlerU = new cycquery(targetBot, user, query, request, result, node);
break;
case "cyccondition":
tagHandlerU = new cyccondition(targetBot, user, query, request, result, node);
break;
case "cycphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "cycparaphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "guard":
tagHandlerU = new guard(targetBot, user, query, request, result, node);
break;
case "guardstar":
tagHandlerU = new guardstar(targetBot, user, query, request, result, node);
break;
case "cycrandom":
tagHandlerU = new cycrandom(targetBot, user, query, request, result, node);
break;
case "tscore":
tagHandlerU = new tscore(targetBot, user, query, request, result, node);
break;
case "space":
tagHandlerU = new space(targetBot, user, query, request, result, node);
break;
case "markov":
tagHandlerU = new markov(targetBot, user, query, request, result, node);
break;
case "soundcode":
tagHandlerU = new soundcode(targetBot, user, query, request, result, node);
break;
// MSM
case "msm":
tagHandlerU = new msm(targetBot, user, query, request, result, node);
break;
case "processmsm":
tagHandlerU = new process_msm(targetBot, user, query, request, result, node);
break;
case "setstate":
tagHandlerU = new setstate(targetBot, user, query, request, result, node);
break;
case "state":
tagHandlerU = new state(targetBot, user, query, request, result, node);
break;
case "transition":
tagHandlerU = new transition(targetBot, user, query, request, result, node);
break;
case "setevidence":
tagHandlerU = new setevidence(targetBot, user, query, request, result, node);
break;
case "evidenceassoc":
tagHandlerU = new evidence_assoc(targetBot, user, query, request, result, node);
break;
case "evidencepattern":
tagHandlerU = new evidence_pattern(targetBot, user, query, request, result, node);
break;
case "evidencestate":
tagHandlerU = new evidencestate(targetBot, user, query, request, result, node);
break;
case "dependentmachine":
tagHandlerU = new dependentmachine(targetBot, user, query, request, result, node);
break;
case "responsetopic":
tagHandlerU = new response_topic(targetBot, user, query, request, result, node);
break;
case "push":
tagHandlerU = new push(targetBot, user, query, request, result, node);
break;
case "pop":
tagHandlerU = new pop(targetBot, user, query, request, result, node);
break;
case "peekstack":
tagHandlerU = new peekstack(targetBot, user, query, request, result, node);
break;
case "lex":
tagHandlerU = new lex(targetBot, user, query, request, result, node);
break;
case "lexset":
tagHandlerU = new lexset(targetBot, user, query, request, result, node);
break;
case "lexis":
tagHandlerU = new lexis(targetBot, user, query, request, result, node);
break;
case "dbpush":
tagHandlerU = new dbpush(targetBot, user, query, request, result, node);
break;
case "dbquery":
tagHandlerU = new dbquery(targetBot, user, query, request, result, node);
break;
case "dbupdate":
tagHandlerU = new dbupdate(targetBot, user, query, request, result, node);
break;
case "dbdelete":
tagHandlerU = new dbdelete(targetBot, user, query, request, result, node);
break;
case "dbload":
tagHandlerU = new dbload(targetBot, user, query, request, result, node);
break;
case "regex":
tagHandlerU = new regex(targetBot, user, query, request, result, node);
break;
case "bind": // <bind>#$isa</bind>
tagHandlerU = new bind(targetBot, user, query, request, result, node);
break;
case "#text":
if (!liText)
{
return(null);
}
return(new verbatum(node.Value, targetBot, user, query, request, result, node));
case "#comment":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
case "br":
return(new verbatum("\n", targetBot, user, query, request, result, node));
case "pre":
return(new verbatum(StaticXMLUtils.InnerXmlText(node), targetBot, user, query, request, result, node));
case "p":
return(new verbatum("\n\n", targetBot, user, query, request, result, node));
case "meta":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
default:
break;
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (StaticAIMLUtils.IsHtmlTag(node.Name))
{
return(new recursiveVerbatum(node, targetBot, user, query, request, result, node, true));
}
if (tagHandlerU == null)
{
// "bot", "favorite", "fav"
foreach (KeyValuePair <string, string> prefix in new[]
{
new KeyValuePair <string, string>("get_", "get"),
new KeyValuePair <string, string>("set_", "set"),
new KeyValuePair <string, string>("bot_", "bot"),
new KeyValuePair <string, string>("favorite_", "bot"),
new KeyValuePair <string, string>("favorite", "bot"),
new KeyValuePair <string, string>("fav_", "bot"),
new KeyValuePair <string, string>("fav", "bot"),
new KeyValuePair <string, string>("get", "get"),
new KeyValuePair <string, string>("set", "set"),
new KeyValuePair <string, string>("bot", "bot"),
})
{
if (nodeNameLower.StartsWith(prefix.Key) && node.Name.Length > prefix.Key.Length)
{
string name = node.Name.Substring(prefix.Key.Length);
XmlNode pn = node.ParentNode;
LineInfoElementImpl newnode = StaticXMLUtils.CopyNode(prefix.Value, node, false);
XmlAttributeLineInfo atr = (XmlAttributeLineInfo)newnode.OwnerDocument.CreateAttribute("name");
atr.ReadOnly = false;
atr.Value = name;
newnode.Attributes.Append(atr);
if (node.Name.ToLower() != newnode.Name.ToLower())
{
writeToLog("AIMLLOADER: converted " + node.OuterXml + " -> " + newnode.OuterXml);
return(targetBot.GetTagHandler(newnode, query, request, result, user, liText));
}
writeToLog("AIMLLOADER: ! convert " + node.OuterXml + " -> " + newnode.OuterXml);
}
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (nodeNameLower == "name")
{
return(new bot(targetBot, user, query, request, result, node));
}
tagHandlerU = new lazyClosure(targetBot, user, query, request, result, node);
writeToLog("AIMLLOADER: lazyClosure: " + node.OuterXml);
return(tagHandlerU);
}
private void loadfile_Click(object sender, EventArgs e)
{
fopen.ShowDialog();
String filename = fopen.FileName;
try
{
if (bfile != null)
{
bfile.Close();
}
bfile = File.Open(filename, FileMode.Open);
}
catch (Exception e1)
{
string s1 = e1.Message;
Exception e2 = e1.InnerException;
while (e2 != null)
{
s1 = s1 + "\n" + e2.Message;
e2 = e1.InnerException;
}
MessageBox.Show(s1, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (!bfile.CanRead)
{
return;
}
b = new BinaryReader(bfile);
filelabel.Text = "Opened: " + fopen.SafeFileName;
next.Enabled = false;
previous.Enabled = false;
int flag = 0;
s = new format();
byte[] b1 = new byte[32];
byte[] glob = new byte[24];
glob = b.ReadBytes(24);
for (int i = 0; i < 24; i++)
{
if (glob[i] == s.global[i])
{
continue;
}
else
{
flag = 1;
}
}
if (flag == 1)
{
MessageBox.Show("Global Header Error. File is not a valid CAP/PCAP file", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
txtinfo.Clear();
filelabel.Text = "Opened: (none)";
}
else
{
next.Enabled = true;
previous.Enabled = true;
display(true);
}
}
I took "G6" for my needs. If a value is greater than 5 decimal the output is x.yE-05 for a decimal value 0.0000xy but javascript reconize correctly this format number.
result = (tResult as IFormattable).ToString(format, culture); //
public static void Print(string format, params object[] args) => Debug.Print($"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}]: {string.Format(format, args)}");
private void buttonPrintA3_Click(object sender, EventArgs e)
{
f = format.A3;
dlgPrintPreview.ShowDialog();
}
public static void AddBinFormat(FlatBufferBuilder builder, format binFormat)
{
builder.AddSbyte(3, (sbyte)binFormat, 1);
}
WithParamList(prx, operationName, idempotent, compress, format, context, in paramList, writer);
=> (parameter is string format) ? string.Format(format, value) : value.ToString();
: super(format, folderId)
{
this.itemId = itemId;
}
=> Console.WriteLine($"[{DateTime.Now:HH\\:mm\\:ss.fff}][{nameof(Program)}] {string.Format(format, args)}");
: GetAvatarUrl(format, size);
(string.Format(format, i.ToString().PadLeft(2, '0')), generator.Generate(i))
new ConcreteFormattableString(format, arguments);
obj is IFormattable formattable?formattable.ToString(format, null) : string.Format(format, obj);
new(id, string.Format(format, symbol.ToDisplayString(), leftName, rightName), type, symbol);
static void Main(string[] args)
{
/* string s = "-k dfsdfhsdkfjhsdkf-sdfsdf-sd-f-sdf -s 1.0 -v zahar";
* string[] parts = Regex.Split(s, " (?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)");
* foreach (string part in parts)
* Console.WriteLine(part);
* Console.ReadLine();*/
if (args.Count() > 0)
{
if (args[0] == "-h")
{
Console.WriteLine("Синтезатор речи с использованием сервисов Яндекс\n\n");
Console.WriteLine("Использование:\n");
Console.WriteLine("\t-k <ключ> -t <текст> [-f <mp3,wav>] [-v <jane, oksana, alyss, omazh, zahar, ermil>]");
Console.WriteLine("\t[-q <h,l>] [-s <скорость>] [-e <g, n, e>] [-o <файл>] [-s] \n\n");
Console.WriteLine("Параметры:\n");
Console.WriteLine("\t-k\t\tAPI-ключ");
Console.WriteLine("\t-t\t\tТекст, который нужно озвучить. \n\t\t\tДля передачи слов-омографов используйте + перед ударной гласной. Например, гот+ов или def+ect.");
Console.WriteLine("\t-f\t\tРасширение синтезируемого файла (его формат). Допустимые значения:\n\t\t\t\tmp3 — аудио в формате MPEG\n\t\t\t\twav — аудио в формате PCM 16 бит");
Console.WriteLine("\t-v\t\tГолос синтезированной речи. Можно выбрать один из следующих голосов:\n\t\t\t\tjane, oksana, alyss, omazh, zahar, ermil.");
Console.WriteLine("\t-q\t\tЧастота дискретизации и битрейт синтезируемого PCM-аудио (медиаконтейнер WAV). Допустимые значения:\n\t\t\t\th — частота дискретизации 48 кГц и битрейт 768 кб/c;\n\t\t\t\tl — частота дискретизации 8 кГц и битрейт 128 кб/c.");
Console.WriteLine("\t-s\t\tСкорость (темп) синтезированной речи. \n\t\t\tСкорость речи задается дробным числом в диапазоне от 0.1 до 3.0");
Console.WriteLine("\t-e\t\tЭмоциональная окраска голоса. Допустимые значения: \n\t\t\t\tg — радостный, доброжелательный;\n\t\t\t\te — раздраженный;\n\t\t\t\tn — нейтральный (используется по умолчанию).");
Console.WriteLine("\t-p\t\tВоспроизвести озвученный текст. (Только в wav-формате)");
Console.WriteLine("\t-o\t\tСохранить в файл");
}
string key = String.Empty, text = String.Empty;
format format = format.wav;
speaker voice = speaker.jane;
double speed = 1.0;
quality quality = quality.lo;
emotion emotion = emotion.neutral;
bool isPlay = false, isSave = false;
string file = "";
try
{
for (int i = 0; i < args.Count(); i++)
{
switch (args[i])
{
case "-k":
key = args[i + 1];
//Console.WriteLine("key is " + args[i + 1]);
break;
case "-t":
text = args[i + 1];
break;
case "-f":
switch (args[i + 1])
{
case "wav":
format = format.wav;
break;
case "mp3":
format = format.mp3;
break;
default:
format = format.wav;
break;
}
break;
case "-v":
switch (args[i + 1])
{
case "alyss":
voice = speaker.alyss;
break;
case "ermil":
voice = speaker.ermil;
break;
case "jane":
voice = speaker.jane;
break;
case "oksana":
voice = speaker.oksana;
break;
case "omazh":
voice = speaker.omazh;
break;
case "zahar":
voice = speaker.zahar;
break;
default:
voice = speaker.jane;
break;
}
break;
case "-q":
switch (args[i + 1])
{
case "h":
quality = quality.hi;
break;
case "l":
quality = quality.lo;
break;
default:
quality = quality.lo;
break;
}
break;
case "-s":
speed = Double.TryParse(args[i + 1].Replace(',', '.'), out speed) ? Double.Parse(args[i + 1].Replace(',', '.')) : 1.0;
break;
case "-e":
switch (args[i + 1])
{
case "g":
emotion = emotion.good;
break;
case "n":
emotion = emotion.neutral;
break;
case "e":
emotion = emotion.evil;
break;
default:
emotion = emotion.neutral;
break;
}
break;
case "-p":
isPlay = true;
break;
case "-o":
isSave = true;
file = args[i + 1];
break;
}
}
if (String.IsNullOrEmpty(key) && String.IsNullOrEmpty(text))
{
Console.WriteLine("Невеный формат команд"); return;
}
}
catch (Exception) { Console.WriteLine("Невеный формат команд"); }
MemoryStream stream = new MemoryStream(); Speech.Synthes(key, text, format, voice, quality, speed, emotion).CopyTo(stream);
if (stream == null)
{
Console.WriteLine("Не удалось синтезировать"); return;
}
if (isPlay)
{
SoundPlayer player = new SoundPlayer(stream);
player.PlaySync();
}
int f = 0;
try
{
if (isSave)
{
f = 1;
// запись в файл
using (var sr1 = new FileStream(file, FileMode.Create))
{
f = 2;
// преобразуем строку в байты
byte[] bytesInStream = stream.ToArray();
stream.Read(bytesInStream, 0, bytesInStream.Length);
f = 3;
// Use write method to write to the file specified above
sr1.Write(bytesInStream, 0, bytesInStream.Length);
}
/*
* using (FileStream fileStream = File.Create(file, (int)stream.Length))
* {
* f = 2;
* byte[] data = new byte[stream.Length];
*
* // stream.Read(data, 0, (int)data.Length);
* fileStream.Write(data, 0, data.Length);
* }*/
}
}
catch (Exception ex) { Console.WriteLine(ex.Message + " " + f); }
// Speech.Synthes("","", format.mp3,,quality.lo,,)
}
}
: string.Format(format, obj);
var(format, options) = FormatParser.Parse(formatOptions);
