public void WriteXml(XmlWriter writer)
{
writer.WriteStartAttribute("dateTime");
writer.WriteRaw(dateTimeField.ToString("yyyy-MM-dd"));
writer.WriteEndAttribute();
if (sourceIDSpecified)
{
writer.WriteStartAttribute("sourceID");
writer.WriteRaw(sourceIDField.ToString());
writer.WriteEndAttribute();
}
if (methodIDSpecified)
{
writer.WriteStartAttribute("methodID");
writer.WriteRaw(methodIDField.ToString());
writer.WriteEndAttribute();
}
if (sampleIDFieldSpecified)
{
writer.WriteStartAttribute("sampleID");
writer.WriteRaw(methodIDField.ToString());
writer.WriteEndAttribute();
}
writer.WriteValue(valueField);
}
public XmlWriterTraceListener (TextWriter writer, string name)
: base (writer, name)
{
XmlWriterSettings settings = new XmlWriterSettings ();
settings.OmitXmlDeclaration = true;
w = XmlWriter.Create (writer, settings);
}
private static void WritePackageDetails(XmlWriter writer, List<FileDetails> selectedResxFiles,PackageInfo package)
{
writer.WriteStartElement("package");
writer.WriteAttributeString("name", package.PackageName);
writer.WriteAttributeString("type", package.PackageType);
writer.WriteAttributeString("version", package.Version);
writer.WriteElementString("friendlyname", package.FriendlyName);
writer.WriteElementString("description", package.Description);
writer.WriteStartElement("owner");
writer.WriteElementString("name", package.OwnerName);
writer.WriteElementString("organization",package.Organistaion);
writer.WriteElementString("url","");
writer.WriteElementString("email", package.Email);
writer.WriteEndElement();
writer.WriteElementString("license", package.License);
writer.WriteElementString("releasenotes", package.ReleaseNotes);
writer.WriteStartElement("components");
writer.WriteStartElement("component");
writer.WriteAttributeString("type", "CoreLanguage");
writer.WriteStartElement("languagefiles");
writer.WriteElementString("code","");
writer.WriteElementString("displayname", "");
writer.WriteElementString("fallback", "");
WritePackageResources(writer,selectedResxFiles);
WritePackageEndElements(writer);
}
public void WriteXml(XmlWriter writer)
{
writer.WriteStartElement("name");
writer.WriteValue(this.name);
writer.WriteEndElement();
writer.WriteStartElement("extension");
writer.WriteValue(this.extension);
writer.WriteEndElement();
writer.WriteStartElement("data");
XmlDictionaryWriter dictWriter = writer as XmlDictionaryWriter;
bool isMtom = dictWriter != null && dictWriter is IXmlMtomWriterInitializer;
if (isMtom)
{
dictWriter.WriteValue(new MyStreamProvider(this.stream));
}
else
{
// fall back to the original behavior
byte[] buffer = new byte[1000];
int bytesRead;
do
{
bytesRead = this.stream.Read(buffer, 0, buffer.Length);
if (bytesRead > 0)
{
writer.WriteBase64(buffer, 0, bytesRead);
}
} while (bytesRead > 0);
}
writer.WriteEndElement();
}
public static void Write(ProjectManager projects, string path, IdTable ids) {
foreach ( var p in projects ) {
if ( p == Project.Empty ) continue;
var f = new XmlWriter(path + p.Name + ".xml");
f.Begin(p, ids);
f.Begin("Assignments");
var faclist = new FlatAssignmentCollection[p.Assignments.Count];
lock ( p.Assignments ) p.Assignments.CopyTo(faclist, 0);
foreach ( var fac in faclist ) {
f.Begin(fac, ids);
var falist = new FlatAssignment[fac.Count];
lock ( fac ) fac.CopyTo(falist, 0);
foreach ( var fa in falist ) f.Write(fa, ids);
f.End(fac);
}
f.End("Assignments");
f.Begin("Costs");
var costlist = new Cost[p.Costs.Count];
lock ( p.Costs ) p.Costs.CopyTo(costlist, 0);
foreach ( var c in costlist ) {
f.Begin(c, ids);
f.Begin("Options");
var optionslist = new CostOptions[c.Options.Count];
lock ( c.Options ) c.Options.CopyTo(optionslist, 0);
foreach ( var o in optionslist ) f.Write(o, ids);
f.End("Options");
f.End(c);
}
f.End("Costs");
f.End(p);
f.Close();
}
}
private static void WriteAlbum(XmlWriter writer, string title, string artist)
{
writer.WriteStartElement("album");
writer.WriteElementString("title", title);
writer.WriteElementString("author", artist);
writer.WriteEndElement();
}
public RssWriter(XmlWriter tw)
{
m_writer = tw;
links = Links.Instance;
gui = GUIVariables.Instance;
}
internal static void Encode(byte[] buffer, int index, int count, XmlWriter writer)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
if (count > buffer.Length - index)
{
throw new ArgumentOutOfRangeException(nameof(count));
}
char[] chars = new char[(count * 2) < CharsChunkSize ? (count * 2) : CharsChunkSize];
int endIndex = index + count;
while (index < endIndex)
{
int cnt = (count < CharsChunkSize / 2) ? count : CharsChunkSize / 2;
int charCount = Encode(buffer, index, cnt, chars);
writer.WriteRaw(chars, 0, charCount);
index += cnt;
count -= cnt;
}
}
private void SaveEnemies(XmlWriter wr) {
wr.WriteStartElement ("Enemies");
foreach(GameObject go in enemies) {
go.GetComponent<Enemy> ().Save (wr);
}
wr.WriteEndElement ();
}
// this method must be called before any generated serialization methods are called
internal void Init(XmlWriter w, XmlSerializerNamespaces namespaces, string encodingStyle, string idBase, TempAssembly tempAssembly) {
this.w = w;
this.namespaces = namespaces;
this.soap12 = (encodingStyle == Soap12.Encoding);
this.idBase = idBase;
Init(tempAssembly);
}
public WixScriptBuilder(XmlWriter writer, IFolder basePath, WixBuilderParameters parameters)
{
parameters.Validate();
_writer = writer;
_basePath = basePath;
_parameters = parameters;
InitializeFileIdMappings(parameters);
}
private static void WriteBook(XmlWriter writer, string title, string author, string isbn)
{
writer.WriteStartElement("book");
writer.WriteElementString("title", title);
writer.WriteElementString("author", author);
writer.WriteElementString("isbn", isbn);
writer.WriteEndElement();
}
public void Write(XmlWriter writer)
{
writer.WriteStartElement(Element.AgentDependency);
writer.WriteAttributeString(Manifest.Attribute.XMLNamespace, Manifest.Value.AndroidNameSpace);
writer.WriteAttributeString(Attribute.version, VersionName);
for (int i = 0; i < Agents.Count; i++) Agents[i].Write(writer);
writer.WriteEndElement();
}
public static string ToString(Variant value, XmlMode mode)
{
using (System.IO.TextWriter ms = new System.IO.StringWriter())
{
XmlWriter writer = new XmlWriter(ms, mode);
writer.WriteDocument(value);
return ms.ToString();
}
}
/// <summary>
/// Default document as XPathNavigator.
/// </summary>
public override void Execute(IXPathNavigable contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlWriter results) {
if (results == null)
throw new ArgumentNullException(nameof(results));
if (contextDocument != null)
Execute(contextDocument.CreateNavigator(), dataSources, argumentList, results, false);
else
Execute(null, dataSources, argumentList, results, false);
}
public override void WriteObject(XmlWriter writer, object graph)
{
SimpleEventRequest SimpleEventRequestField = ((SimpleEventRequest)(graph));
if (WriteParentElement(writer, true, true, graph))
{
writer.WriteEndElement();
}
return;
}
public static void WritePerson(XmlWriter writer, string name, string address, string phone)
{
writer.WriteStartElement("person");
{
writer.WriteElementString("name", name);
writer.WriteElementString("address", address);
writer.WriteElementString("phone", phone);
}
writer.WriteEndElement();
}
/// <summary>
/// Writes out the credential element. Used in Workbook and Data Source publication
/// </summary>
/// <param name="xmlWriter"></param>
/// <param name="connectionUserName"></param>
/// <param name="password"></param>
/// <param name="isEmbedded"></param>
public static void WriteCredential(XmlWriter xmlWriter, string connectionUserName, string password, bool isEmbedded)
{
// <connectionCredentials name="connection-username" password="******"
// embed="embed-flag" />
xmlWriter.WriteStartElement("connectionCredentials");
xmlWriter.WriteAttributeString("name", connectionUserName);
xmlWriter.WriteAttributeString("password", password);
XmlHelper.WriteBooleanAttribute(xmlWriter, "embed", isEmbedded);
xmlWriter.WriteEndElement();
}
public override void WriteObject(XmlWriter writer, object graph)
{
AnyCheckRequest AnyCheckRequestField = ((AnyCheckRequest)(graph));
if (WriteParentElement(writer, true, true, graph))
{
WriteAnyAttribute(writer, AnyCheckRequestField.AnyAttr);
WriteAnyElement(writer, AnyCheckRequestField.Any, false);
writer.WriteEndElement();
}
return;
}
void IXmlSerializable.WriteXml(XmlWriter w)
{
w.WriteStartElement("Employee", ns);
w.WriteStartElement("Name", ns);
w.WriteElementString("First", ns, FirstName);
w.WriteElementString("Last", ns, LastName);
w.WriteEndElement();
w.WriteElementString("ID", ns, ID.ToString());
w.WriteEndElement();
}
/// <summary>
/// Write this <see cref="XText"/> to the given <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">
/// The <see cref="XmlWriter"/> to write this <see cref="XText"/> to.
/// </param>
public override void WriteTo(XmlWriter writer)
{
if (writer == null) throw new ArgumentNullException(nameof(writer));
if (parent is XDocument)
{
writer.WriteWhitespace(text);
}
else
{
writer.WriteString(text);
}
}
private static void TraverseDirectory(XmlWriter writer, string path)
{
writer.WriteStartElement("dir");
writer.WriteAttributeString("name", FormatPath(path));
foreach (var directory in Directory.EnumerateDirectories(path))
TraverseDirectory(writer, directory);
foreach (var file in Directory.EnumerateFiles(path))
writer.WriteElementString("file", FormatPath(file));
writer.WriteEndElement();
}
public override void WriteObject(XmlWriter writer, object graph)
{
GetData GetDataField = ((GetData)(graph));
if (WriteParentElement(writer, true, true, graph))
{
if (WriteChildElement(writer, "value", false, false, GetDataField.value))
{
writer.WriteString(XmlConvert.ToString(GetDataField.value));
writer.WriteEndElement();
}
writer.WriteEndElement();
}
return;
}
public override void WriteObject(XmlWriter writer, object graph)
{
ArrayOfLoanStateCompositeType ArrayOfLoanStateCompositeTypeField = ((ArrayOfLoanStateCompositeType)(graph));
if (WriteParentElement(writer, true, true, graph))
{
LoanStateCompositeTypeDataContractSerializer LoanStateCompositeTypeDCS = new LoanStateCompositeTypeDataContractSerializer("LoanStateCompositeType", "http://schemas.datacontract.org/2004/07/", "http://schemas.datacontract.org/2004/07/");
for (int i = 0; (i < ArrayOfLoanStateCompositeTypeField.LoanStateCompositeType.Length); i = (i + 1))
{
LoanStateCompositeTypeDCS.WriteObject(writer, ArrayOfLoanStateCompositeTypeField.LoanStateCompositeType[i]);
}
writer.WriteEndElement();
}
return;
}
public override void WriteObject(XmlWriter writer, object graph)
{
HelloWCF HelloWCFField = ((HelloWCF)(graph));
if (WriteParentElement(writer, true, true, graph))
{
if (WriteChildElement(writer, "name", false, true, HelloWCFField.name))
{
writer.WriteString(HelloWCFField.name);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
return;
}
public void addPattern(XmlWriter writer, string pattern, string name)
{
// clean up the path
pattern = pattern.Replace("Assets/StreamingAssets/", "");
Debug.Log("new pattern" +pattern);
writer.WriteStartElement("SensorCOS");
writer.WriteElementString("SensorCosID", name);
writer.WriteStartElement("Parameters");
writer.WriteElementString("ReferenceImage", pattern);
writer.WriteElementString("SimilarityThreshold", "0.7");
writer.WriteEndElement();
writer.WriteEndElement();
}
public void WriteXml(XmlWriter writer)
{
int moduleIndex = 0;
foreach (XPathModuleInfo module in XPathModules.Modules) {
string modulePrefix = (module.Predeclare) ? module.PredeclarePrefix
: module.NamespaceBindings.ContainsValue(module.Namespace) ? module.NamespaceBindings.First(p => p.Value == module.Namespace).Key
: "m" + (++moduleIndex);
writer.WriteStartElement("module");
writer.WriteAttributeString("namespace", module.Namespace);
writer.WriteAttributeString("cref", CRef(module.Type));
if (module.Predeclare) {
writer.WriteAttributeString("predeclaredPrefix", modulePrefix);
}
foreach (var item in module.NamespaceBindings) {
writer.WriteAttributeString("xmlns", item.Key, null, item.Value);
}
if (!module.NamespaceBindings.ContainsKey(modulePrefix)) {
writer.WriteAttributeString("xmlns", modulePrefix, null, module.Namespace);
}
foreach (XPathFunctionInfo function in module.Functions) {
writer.WriteStartElement("function");
writer.WriteAttributeString("name", modulePrefix + ":" + function.Name);
writer.WriteAttributeString("as", function.ReturnType.ToString());
writer.WriteAttributeString("hasSideEffects", XmlConvert.ToString(function.HasSideEffects));
writer.WriteAttributeString("cref", CRef(function.Method));
foreach (XPathVariableInfo param in function.Parameters) {
writer.WriteStartElement("param");
writer.WriteAttributeString("name", param.Name);
writer.WriteAttributeString("as", param.Type.ToString());
writer.WriteEndElement(); // param
}
writer.WriteEndElement(); // function
}
writer.WriteEndElement(); // module
}
}
public override void WriteObject(XmlWriter writer, object graph)
{
OneWayRequest OneWayRequestField = ((OneWayRequest)(graph));
if (WriteParentElement(writer, true, true, graph))
{
WriteAnyAttribute(writer, OneWayRequestField.AnyAttr);
if (WriteChildElement(writer, "Param", true, true, OneWayRequestField.Param))
{
writer.WriteString(XmlConvert.ToString(OneWayRequestField.Param));
writer.WriteEndElement();
}
WriteAnyElement(writer, OneWayRequestField.Any, false);
writer.WriteEndElement();
}
return;
}
public static void Write(LesseeManager lessees, string filepath, IdTable ids) {
var f = new XmlWriter(filepath);
f.Begin("Lessees");
var list = new Lessee[lessees.Count];
lock ( lessees ) lessees.CopyTo(list, 0);
foreach ( var l in list ) {
f.Begin(l, ids);
f.Begin("Payments");
var paymentlist = new AdvancePayment[l.Payments.Count];
lock ( l.Payments ) l.Payments.CopyTo(paymentlist, 0);
foreach ( var p in paymentlist ) f.Write(p, ids);
f.End("Payments");
f.End(l);
}
f.End("Lessees");
f.Close();
}
public static void Write(PropertyManager properties, string filepath, IdTable ids) {
var f = new XmlWriter(filepath);
f.Begin("Properties");
var list = new Olivia2.Model.Property[properties.Count];
lock ( properties ) properties.CopyTo(list, 0);
foreach (var p in list) {
f.Begin(p, ids);
f.Begin("Flats");
var flatlist = new Flat[p.Flats.Count];
lock ( p.Flats ) p.Flats.CopyTo(flatlist, 0);
foreach ( var flat in flatlist ) f.Write(flat, ids);
f.End("Flats");
f.End(p);
}
f.End("Properties");
f.Close();
}
private void WriteAttribute(CompiledXPathNode node, XmlWriter writer)
{
writer.WriteStartAttribute(node.Prefix, node.LocalName, null);
WriteValue(node, writer);
writer.WriteEndAttribute();
}
public void WriteXml(XmlWriter writer) { }
/// <summary>
/// Output this task out to an XML writer.
/// </summary>
public override void Write(XmlWriter Writer)
{
Write(Writer, Parameters);
}
private void AddVideoResource(DlnaOptions options, XmlWriter writer, BaseItem video, string deviceId, Filter filter, StreamInfo streamInfo = null)
{
if (streamInfo == null)
{
var sources = _mediaSourceManager.GetStaticMediaSources(video, true, _user);
streamInfo = new StreamBuilder(_mediaEncoder, GetStreamBuilderLogger(options)).BuildVideoItem(new VideoOptions
{
ItemId = video.Id,
MediaSources = sources.ToArray(),
Profile = _profile,
DeviceId = deviceId,
MaxBitrate = _profile.MaxStreamingBitrate
});
}
var targetWidth = streamInfo.TargetWidth;
var targetHeight = streamInfo.TargetHeight;
var contentFeatureList = new ContentFeatureBuilder(_profile).BuildVideoHeader(streamInfo.Container,
streamInfo.TargetVideoCodec.FirstOrDefault(),
streamInfo.TargetAudioCodec.FirstOrDefault(),
targetWidth,
targetHeight,
streamInfo.TargetVideoBitDepth,
streamInfo.TargetVideoBitrate,
streamInfo.TargetTimestamp,
streamInfo.IsDirectStream,
streamInfo.RunTimeTicks ?? 0,
streamInfo.TargetVideoProfile,
streamInfo.TargetVideoLevel,
streamInfo.TargetFramerate ?? 0,
streamInfo.TargetPacketLength,
streamInfo.TranscodeSeekInfo,
streamInfo.IsTargetAnamorphic,
streamInfo.IsTargetInterlaced,
streamInfo.TargetRefFrames,
streamInfo.TargetVideoStreamCount,
streamInfo.TargetAudioStreamCount,
streamInfo.TargetVideoCodecTag,
streamInfo.IsTargetAVC);
foreach (var contentFeature in contentFeatureList)
{
AddVideoResource(writer, video, deviceId, filter, contentFeature, streamInfo);
}
var subtitleProfiles = streamInfo.GetSubtitleProfiles(_mediaEncoder, false, _serverAddress, _accessToken)
.Where(subtitle => subtitle.DeliveryMethod == SubtitleDeliveryMethod.External)
.ToList();
foreach (var subtitle in subtitleProfiles)
{
var subtitleAdded = AddSubtitleElement(writer, subtitle);
if (subtitleAdded && _profile.EnableSingleSubtitleLimit)
{
break;
}
}
}
public void Write (T value, XmlWriter writer)
{
writer.WriteString (Enum.GetName (_type, value));
}
void WriteEventCategory(XmlWriter w, PerformanceEventArrivedEventArgs e)
{
w.WriteAttributeString("Component", e.ComponentName);
w.WriteAttributeString("Category", e.CategoryName);
w.WriteAttributeString("Measurement", e.MeasurementName);
}
private void AddVideoResource(XmlWriter writer, BaseItem video, string deviceId, Filter filter, string contentFeatures, StreamInfo streamInfo)
{
writer.WriteStartElement(string.Empty, "res", NS_DIDL);
var url = NormalizeDlnaMediaUrl(streamInfo.ToUrl(_serverAddress, _accessToken));
var mediaSource = streamInfo.MediaSource;
if (mediaSource.RunTimeTicks.HasValue)
{
writer.WriteAttributeString("duration", TimeSpan.FromTicks(mediaSource.RunTimeTicks.Value).ToString("c", _usCulture));
}
if (filter.Contains("res@size"))
{
if (streamInfo.IsDirectStream || streamInfo.EstimateContentLength)
{
var size = streamInfo.TargetSize;
if (size.HasValue)
{
writer.WriteAttributeString("size", size.Value.ToString(_usCulture));
}
}
}
var totalBitrate = streamInfo.TargetTotalBitrate;
var targetSampleRate = streamInfo.TargetAudioSampleRate;
var targetChannels = streamInfo.TargetAudioChannels;
var targetWidth = streamInfo.TargetWidth;
var targetHeight = streamInfo.TargetHeight;
if (targetChannels.HasValue)
{
writer.WriteAttributeString("nrAudioChannels", targetChannels.Value.ToString(_usCulture));
}
if (filter.Contains("res@resolution"))
{
if (targetWidth.HasValue && targetHeight.HasValue)
{
writer.WriteAttributeString("resolution", string.Format("{0}x{1}", targetWidth.Value, targetHeight.Value));
}
}
if (targetSampleRate.HasValue)
{
writer.WriteAttributeString("sampleFrequency", targetSampleRate.Value.ToString(_usCulture));
}
if (totalBitrate.HasValue)
{
writer.WriteAttributeString("bitrate", totalBitrate.Value.ToString(_usCulture));
}
var mediaProfile = _profile.GetVideoMediaProfile(streamInfo.Container,
streamInfo.TargetAudioCodec.FirstOrDefault(),
streamInfo.TargetVideoCodec.FirstOrDefault(),
streamInfo.TargetAudioBitrate,
targetWidth,
targetHeight,
streamInfo.TargetVideoBitDepth,
streamInfo.TargetVideoProfile,
streamInfo.TargetVideoLevel,
streamInfo.TargetFramerate ?? 0,
streamInfo.TargetPacketLength,
streamInfo.TargetTimestamp,
streamInfo.IsTargetAnamorphic,
streamInfo.IsTargetInterlaced,
streamInfo.TargetRefFrames,
streamInfo.TargetVideoStreamCount,
streamInfo.TargetAudioStreamCount,
streamInfo.TargetVideoCodecTag,
streamInfo.IsTargetAVC);
var filename = url.Substring(0, url.IndexOf('?'));
var mimeType = mediaProfile == null || string.IsNullOrEmpty(mediaProfile.MimeType)
? GetMimeType(filename)
: mediaProfile.MimeType;
writer.WriteAttributeString("protocolInfo", String.Format(
"http-get:*:{0}:{1}",
mimeType,
contentFeatures
));
writer.WriteString(url);
writer.WriteFullEndElement();
}
// Token: 0x0600144F RID: 5199 RVA: 0x0004AA99 File Offset: 0x00048C99
private void WriteExecutingUser(XmlWriter writer)
{
writer.WriteElementString("ex", this.serializedExecutingUser);
}
private void AddGeneralProperties(BaseItem item, StubType? itemStubType, BaseItem context, XmlWriter writer, Filter filter)
{
AddCommonFields(item, itemStubType, context, writer, filter);
var hasArtists = item as IHasArtist;
var hasAlbumArtists = item as IHasAlbumArtist;
if (hasArtists != null)
{
foreach (var artist in hasArtists.Artists)
{
AddValue(writer, "upnp", "artist", artist, NS_UPNP);
AddValue(writer, "dc", "creator", artist, NS_DC);
// If it doesn't support album artists (musicvideo), then tag as both
if (hasAlbumArtists == null)
{
AddAlbumArtist(writer, artist);
}
}
}
if (hasAlbumArtists != null)
{
foreach (var albumArtist in hasAlbumArtists.AlbumArtists)
{
AddAlbumArtist(writer, albumArtist);
}
}
if (!string.IsNullOrWhiteSpace(item.Album))
{
AddValue(writer, "upnp", "album", item.Album, NS_UPNP);
}
if (item.IndexNumber.HasValue)
{
AddValue(writer, "upnp", "originalTrackNumber", item.IndexNumber.Value.ToString(_usCulture), NS_UPNP);
if (item is Episode)
{
AddValue(writer, "upnp", "episodeNumber", item.IndexNumber.Value.ToString(_usCulture), NS_UPNP);
}
}
}
private void AddAudioResource(DlnaOptions options, XmlWriter writer, BaseItem audio, string deviceId, Filter filter, StreamInfo streamInfo = null)
{
writer.WriteStartElement(string.Empty, "res", NS_DIDL);
if (streamInfo == null)
{
var sources = _mediaSourceManager.GetStaticMediaSources(audio, true, _user);
streamInfo = new StreamBuilder(_mediaEncoder, GetStreamBuilderLogger(options)).BuildAudioItem(new AudioOptions
{
ItemId = audio.Id,
MediaSources = sources.ToArray(),
Profile = _profile,
DeviceId = deviceId
});
}
var url = NormalizeDlnaMediaUrl(streamInfo.ToUrl(_serverAddress, _accessToken));
var mediaSource = streamInfo.MediaSource;
if (mediaSource.RunTimeTicks.HasValue)
{
writer.WriteAttributeString("duration", TimeSpan.FromTicks(mediaSource.RunTimeTicks.Value).ToString("c", _usCulture));
}
if (filter.Contains("res@size"))
{
if (streamInfo.IsDirectStream || streamInfo.EstimateContentLength)
{
var size = streamInfo.TargetSize;
if (size.HasValue)
{
writer.WriteAttributeString("size", size.Value.ToString(_usCulture));
}
}
}
var targetAudioBitrate = streamInfo.TargetAudioBitrate;
var targetSampleRate = streamInfo.TargetAudioSampleRate;
var targetChannels = streamInfo.TargetAudioChannels;
var targetAudioBitDepth = streamInfo.TargetAudioBitDepth;
if (targetChannels.HasValue)
{
writer.WriteAttributeString("nrAudioChannels", targetChannels.Value.ToString(_usCulture));
}
if (targetSampleRate.HasValue)
{
writer.WriteAttributeString("sampleFrequency", targetSampleRate.Value.ToString(_usCulture));
}
if (targetAudioBitrate.HasValue)
{
writer.WriteAttributeString("bitrate", targetAudioBitrate.Value.ToString(_usCulture));
}
var mediaProfile = _profile.GetAudioMediaProfile(streamInfo.Container,
streamInfo.TargetAudioCodec.FirstOrDefault(),
targetChannels,
targetAudioBitrate,
targetSampleRate,
targetAudioBitDepth);
var filename = url.Substring(0, url.IndexOf('?'));
var mimeType = mediaProfile == null || string.IsNullOrEmpty(mediaProfile.MimeType)
? GetMimeType(filename)
: mediaProfile.MimeType;
var contentFeatures = new ContentFeatureBuilder(_profile).BuildAudioHeader(streamInfo.Container,
streamInfo.TargetAudioCodec.FirstOrDefault(),
targetAudioBitrate,
targetSampleRate,
targetChannels,
targetAudioBitDepth,
streamInfo.IsDirectStream,
streamInfo.RunTimeTicks ?? 0,
streamInfo.TranscodeSeekInfo);
writer.WriteAttributeString("protocolInfo", String.Format(
"http-get:*:{0}:{1}",
mimeType,
contentFeatures
));
writer.WriteString(url);
writer.WriteFullEndElement();
}
private void WriteSimpleElement(CompiledXPathNode node, XmlWriter writer)
{
writer.WriteStartElement(node.Prefix, node.LocalName, null);
WriteValue(node, writer);
writer.WriteEndElement();
}
private void WriteObjectClass(XmlWriter writer, BaseItem item, StubType? stubType)
{
// More types here
// http://oss.linn.co.uk/repos/Public/LibUpnpCil/DidlLite/UpnpAv/Test/TestDidlLite.cs
writer.WriteStartElement("upnp", "class", NS_UPNP);
if (item.IsDisplayedAsFolder || stubType.HasValue)
{
string classType = null;
if (!_profile.RequiresPlainFolders)
{
if (item is MusicAlbum)
{
classType = "object.container.album.musicAlbum";
}
else if (item is MusicArtist)
{
classType = "object.container.person.musicArtist";
}
else if (item is Series || item is Season || item is BoxSet || item is Video)
{
classType = "object.container.album.videoAlbum";
}
else if (item is Playlist)
{
classType = "object.container.playlistContainer";
}
else if (item is PhotoAlbum)
{
classType = "object.container.album.photoAlbum";
}
}
writer.WriteString(classType ?? "object.container.storageFolder");
}
else if (string.Equals(item.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase))
{
writer.WriteString("object.item.audioItem.musicTrack");
}
else if (string.Equals(item.MediaType, MediaType.Photo, StringComparison.OrdinalIgnoreCase))
{
writer.WriteString("object.item.imageItem.photo");
}
else if (string.Equals(item.MediaType, MediaType.Video, StringComparison.OrdinalIgnoreCase))
{
if (!_profile.RequiresPlainVideoItems && item is Movie)
{
writer.WriteString("object.item.videoItem.movie");
}
else if (!_profile.RequiresPlainVideoItems && item is MusicVideo)
{
writer.WriteString("object.item.videoItem.musicVideoClip");
}
else
{
writer.WriteString("object.item.videoItem");
}
}
else if (item is MusicGenre)
{
writer.WriteString(_profile.RequiresPlainFolders ? "object.container.storageFolder" : "object.container.genre.musicGenre");
}
else if (item is Genre || item is GameGenre)
{
writer.WriteString(_profile.RequiresPlainFolders ? "object.container.storageFolder" : "object.container.genre");
}
else
{
writer.WriteString("object.item");
}
writer.WriteFullEndElement();
}
/// <summary>
/// Adds fields used by both items and folders
/// </summary>
private void AddCommonFields(BaseItem item, StubType? itemStubType, BaseItem context, XmlWriter writer, Filter filter)
{
// Don't filter on dc:title because not all devices will include it in the filter
// MediaMonkey for example won't display content without a title
//if (filter.Contains("dc:title"))
{
AddValue(writer, "dc", "title", GetDisplayName(item, itemStubType, context), NS_DC);
}
WriteObjectClass(writer, item, itemStubType);
if (filter.Contains("dc:date"))
{
if (item.PremiereDate.HasValue)
{
AddValue(writer, "dc", "date", item.PremiereDate.Value.ToString("o"), NS_DC);
}
}
if (filter.Contains("upnp:genre"))
{
foreach (var genre in item.Genres)
{
AddValue(writer, "upnp", "genre", genre, NS_UPNP);
}
}
foreach (var studio in item.Studios)
{
AddValue(writer, "upnp", "publisher", studio, NS_UPNP);
}
if (!(item is Folder))
{
if (filter.Contains("dc:description"))
{
var desc = item.Overview;
if (!string.IsNullOrWhiteSpace(desc))
{
AddValue(writer, "dc", "description", desc, NS_DC);
}
}
//if (filter.Contains("upnp:longDescription"))
//{
// if (!string.IsNullOrWhiteSpace(item.Overview))
// {
// AddValue(writer, "upnp", "longDescription", item.Overview, NS_UPNP);
// }
//}
}
if (!string.IsNullOrEmpty(item.OfficialRating))
{
if (filter.Contains("dc:rating"))
{
AddValue(writer, "dc", "rating", item.OfficialRating, NS_DC);
}
if (filter.Contains("upnp:rating"))
{
AddValue(writer, "upnp", "rating", item.OfficialRating, NS_UPNP);
}
}
AddPeople(item, writer);
}
