public async Task WriteAsync(Stream stream, TagVersion version)
{
byte[] contentBytes = GetContentBytes(version);
var tagId = Encoding.Default.GetBytes(GetTagId(version));
await stream.WriteAsync(tagId, 0, tagId.Length).ConfigureAwait(false);
switch (version)
{
case TagVersion.V23:
stream.WriteByte((byte)((contentBytes.Length / (256 * 256 * 256))));
stream.WriteByte((byte)((contentBytes.Length % (256 * 256 * 256)) / (256 * 256)));
stream.WriteByte((byte)((contentBytes.Length % (256 * 256)) / 256));
stream.WriteByte((byte)((contentBytes.Length % 256)));
break;
case TagVersion.V24:
stream.WriteByte((byte)((contentBytes.Length / (128 * 128 * 128))));
stream.WriteByte((byte)((contentBytes.Length % (128 * 128 * 128)) / (128 * 128)));
stream.WriteByte((byte)((contentBytes.Length % (128 * 128)) / 128));
stream.WriteByte((byte)((contentBytes.Length % 128)));
break;
default:
throw new ArgumentException($"Unable to write frame with version {version}", nameof(version));
}
stream.WriteByte(0x00);
stream.WriteByte(0x00);
await stream.WriteAsync(contentBytes, 0, contentBytes.Length).ConfigureAwait(false);
}
public async Task WriteAsync(Stream stream, TagVersion version)
{
byte[] contentBytes = GetContentBytes(version);
var tagId = Encoding.Default.GetBytes(GetTagId(version));
await stream.WriteAsync(tagId, 0, tagId.Length).ConfigureAwait(false);
switch (version)
{
case TagVersion.V23:
stream.WriteByte((byte)((contentBytes.Length / (256 * 256 * 256))));
stream.WriteByte((byte)((contentBytes.Length % (256 * 256 * 256)) / (256 * 256)));
stream.WriteByte((byte)((contentBytes.Length % (256 * 256)) / 256));
stream.WriteByte((byte)((contentBytes.Length % 256)));
break;
case TagVersion.V24:
stream.WriteByte((byte)((contentBytes.Length / (128 * 128 * 128))));
stream.WriteByte((byte)((contentBytes.Length % (128 * 128 * 128)) / (128 * 128)));
stream.WriteByte((byte)((contentBytes.Length % (128 * 128)) / 128));
stream.WriteByte((byte)((contentBytes.Length % 128)));
break;
default:
throw new ArgumentException($"Unable to write frame with version {version}", nameof(version));
}
stream.WriteByte(0x00);
stream.WriteByte(0x00);
await stream.WriteAsync(contentBytes, 0, contentBytes.Length).ConfigureAwait(false);
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
switch (version)
{
case TagVersion.V23:
if (tagLength > 1)
{
long startPosition = stream.Position;
int peek = stream.ReadByte();
if (peek == 0x00)
{
Text = await stream.ReadAnsiString(startPosition + tagLength).ConfigureAwait(false);
}
else if (peek == 0x01)
{
Text = await stream.ReadUnicodeStringAsync(startPosition + tagLength).ConfigureAwait(false);
}
else
{
throw new ArgumentException("frame does not contain valid text data!", "frame");
}
}
else
{
throw new ArgumentException("frame does not contain valid text data!", "frame");
}
break;
default:
throw new NotImplementedException("Reading " + version.ToString() + " has not been implemented!");
}
}
public void Dump(XmlWriter writer, bool fullbody)
{
writer.WriteStartElement("tag");
var code = TagCode;
writer.WriteAttributeString("code", code.ToString());
if (SwfDumpService.Verbose)
{
writer.WriteAttributeString("codex", string.Format("{0} - 0x{0:X2}", (int)code));
writer.WriteAttributeString("size", GetDataSize().ToString());
writer.WriteAttributeString("version", TagVersion.ToString());
}
if (fullbody)
{
DumpBody(writer);
}
else
{
DumpShortBody(writer);
}
if (SwfDumpService.DumpRefs)
{
DumpRefs(writer);
}
writer.WriteEndElement();
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
long streamStart = stream.Position;
int encoding = stream.ReadByte();
switch (version)
{
case TagVersion.V24:
case TagVersion.V23:
if (encoding == 0x00)
{
MimeType = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
PictureType = (AttachedPictureType)stream.ReadByte();
Description = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Data = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Data, 0, Data.Length).ConfigureAwait(false);
}
else if (encoding == 0x01)
{
MimeType = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
PictureType = (AttachedPictureType)stream.ReadByte();
Description = await stream.ReadUnicodeStringAsync(streamStart + tagLength).ConfigureAwait(false);
Data = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Data, 0, Data.Length).ConfigureAwait(false);
}
break;
default:
Debug.WriteLine("APIC: Version not implemented - " + version.ToString());
break;
}
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
if (tagLength > 6)
{
long streamStart = stream.Position;
int encoding = stream.ReadByte();
var languageBytes = new byte[3];
await stream.ReadAsync(languageBytes, 0, languageBytes.Length).ConfigureAwait(false);
Language = Encoding.Default.GetString(languageBytes);
switch (encoding)
{
case 0x00:
Description = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Text = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
break;
case 0x01:
Description = await stream.ReadUnicodeStringAsync(streamStart + tagLength).ConfigureAwait(false);
Text = await stream.ReadUnicodeStringAsync(streamStart + tagLength).ConfigureAwait(false);
break;
default:
throw new ArgumentException("Frame has an invalid encoding marker", nameof(stream));
}
}
}
internal override byte[] GetContentBytes(TagVersion version)
{
List <byte> bytes = new List <byte>();
switch (version)
{
case TagVersion.V23:
bytes.Add(0x00);
bytes.AddRange(Encoding.Default.GetBytes("eng"));
if (!string.IsNullOrEmpty(Description))
{
bytes.AddRange(Encoding.Default.GetBytes(Description));
}
bytes.Add(0x00);
if (!string.IsNullOrEmpty(Text))
{
bytes.AddRange(Encoding.Default.GetBytes(Text));
}
bytes.Add(0x00);
break;
case TagVersion.V24:
default:
throw new ArgumentException("Version " + version.ToString() + " is not supported for this frame!", nameof(version));
}
return(bytes.ToArray());
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
switch (version)
{
case TagVersion.V23:
if (tagLength > 1)
{
long startPosition = stream.Position;
int peek = stream.ReadByte();
if (peek == 0x00)
{
Text = await stream.ReadAnsiString(startPosition + tagLength).ConfigureAwait(false);
}
else if (peek == 0x01)
{
Text = await stream.ReadUnicodeStringAsync(startPosition + tagLength).ConfigureAwait(false);
}
else
{
throw new ArgumentException("frame does not contain valid text data!", "frame");
}
}
else
{
throw new ArgumentException("frame does not contain valid text data!", "frame");
}
break;
default:
throw new NotImplementedException("Reading " + version.ToString() + " has not been implemented!");
}
}
internal override byte[] GetContentBytes(TagVersion version)
{
List<byte> bytes = new List<byte>();
switch (version)
{
case TagVersion.V23:
bytes.Add(0x00);
bytes.AddRange(Encoding.Default.GetBytes("eng"));
if (!string.IsNullOrEmpty(Description))
{
bytes.AddRange(Encoding.Default.GetBytes(Description));
}
bytes.Add(0x00);
if (!string.IsNullOrEmpty(Text))
{
bytes.AddRange(Encoding.Default.GetBytes(Text));
}
bytes.Add(0x00);
break;
case TagVersion.V24:
default:
throw new ArgumentException("Version " + version.ToString() + " is not supported for this frame!", nameof(version));
}
return bytes.ToArray();
}
public UpdateWindowViewModel(TagVersion updateVersion, string changelog)
{
UpdateVersion = updateVersion;
Changelog = changelog;
DialogResult = DialogResult.None;
WeakSubscriptionManager.Subscribe(App.Current.Locales, nameof(LocaleManager.UICultureChanged), this);
UpdateCommand = ReactiveCommand.Create(Update);
CancelCommand = ReactiveCommand.Create(Cancel);
}
internal override string GetTagId(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
return "TMED";
default:
throw new NotImplementedException("Frame{" + ToString() + "} has not been implemented for version " + version.ToString());
}
}
public async Task SaveAsAsync(string fileName, bool keepV1Tag, TagVersion version)
{
int startRead = -1;
int endRead = -1;
if (keepV1Tag)
{
FileInfo fileInfo = new FileInfo(OriginalFile);
startRead = MpegStart;
endRead = (int)fileInfo.Length;
}
else
{
startRead = MpegStart;
endRead = MpegEnd;
}
using (var memoryStream = new MemoryStream())
{
await Tag.Write(memoryStream, version).ConfigureAwait(false);
if (memoryStream.Length <= MpegStart && MpegEnd == endRead)
{
//we can write the new Tags to the old Tagspace, which is much quicker
using (var file = File.Open(fileName, FileMode.Open, FileAccess.Write))
{
await memoryStream.CopyToAsync(file).ConfigureAwait(false);
}
}
else
{
using (var file = File.OpenRead(OriginalFile))
{
file.Seek(MpegStart, SeekOrigin.Begin);
var buffer = new byte[4096];
while (file.Position < MpegEnd)
{
int bytesRead = await file.ReadAsync(buffer, 0, (int)Math.Min(MpegEnd - file.Position, buffer.Length)).ConfigureAwait(false);
await memoryStream.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false);
}
}
if (File.Exists(fileName))
{
File.Delete(fileName);
}
using (var file = File.Open(fileName, FileMode.CreateNew, FileAccess.Write))
{
await memoryStream.CopyToAsync(file).ConfigureAwait(false);
}
}
}
}
internal override string GetTagId(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
return "USLT";
case TagVersion.V24:
default:
throw new ArgumentException($"Version {version} is not supported for this frame!", nameof(version));
}
}
internal override string GetTagId(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
return("TDAT");
default:
throw new NotImplementedException("Frame{" + ToString() + "} has not been implemented for version " + version.ToString());
}
}
internal override string GetTagId(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
case TagVersion.V24:
return "APIC";
default:
throw new ArgumentException("Version " + version.ToString() + " is not supported for this frame!", nameof(version));
}
}
internal override string GetTagId(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
return("USLT");
case TagVersion.V24:
default:
throw new ArgumentException($"Version {version} is not supported for this frame!", nameof(version));
}
}
internal override string GetTagId(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
case TagVersion.V24:
return("APIC");
default:
throw new ArgumentException("Version " + version.ToString() + " is not supported for this frame!", nameof(version));
}
}
/// <summary>
/// Convert the URLLinkFrame.
/// </summary>
/// <param name="version">The version.</param>
/// <returns>the RawFrame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameOptions flag = Descriptor.Options;
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteString(Url, Encoding.ASCII);
payload = writer.ToArray();
}
return RawFrame.CreateFrame(Descriptor.Id, flag, payload, version);
}
/// <summary>
/// Convert the URLLinkFrame.
/// </summary>
/// <param name="version">The version.</param>
/// <returns>the RawFrame.</returns>
public override RawFrame Convert(TagVersion version)
{
var flag = Descriptor.GetFlags();
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteString(URL, Encoding.ASCII);
payload = writer.ToArray();
}
return RawFrame.CreateFrame(Descriptor.ID, flag, payload, version);
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
if (tagLength > 3)
{
long streamStart = stream.Position;
OwnerIdentifier = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Identifier = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Identifier, 0, Identifier.Length).ConfigureAwait(false);
}
else
{
throw new ArgumentException("Frame has an invalid length", "frame");
}
}
/// <summary>
/// Convert the values to a raw frame.
/// </summary>
/// <returns>the raw frame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameOptions options = Descriptor.Options;
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteString(Owner, Encoding.GetEncoding(28591), true);
writer.WriteBytes(Data);
payload = writer.ToArray();
}
return RawFrame.CreateFrame(Descriptor.Id, options, payload, version);
}
internal override byte[] GetContentBytes(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
List<byte> bytes = new List<byte>();
bytes.AddRange(Encoding.Default.GetBytes(Description));
bytes.Add(0x00);
bytes.AddRange(Value);
return bytes.ToArray();
default:
throw new NotImplementedException("Writing " + version.ToString() + " has not been implemented!");
}
}
/// <summary>
/// Convert the values to a raw frame.
/// </summary>
/// <returns>the raw frame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameOptions options = Descriptor.Options;
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteEncodingByte(TextEncoding);
writer.WritePreamble(TextEncoding);
writer.WriteString(Content, TextEncoding);
payload = writer.ToArray();
}
return RawFrame.CreateFrame(Descriptor.Id, options, payload, version);
}
/// <summary>
/// Converts a play counter frame to raw frame.
/// </summary>
/// <returns>the raw frame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameOptions flag = Descriptor.Options;
byte[] payload;
using (var writer = new FrameDataWriter(8))
{
writer.WriteUInt64(Counter);
payload = writer.ToArray();
}
RawFrame rawFrame = RawFrame.CreateFrame(Descriptor.Id, flag, payload, version);
return rawFrame;
}
internal override byte[] GetContentBytes(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
List <byte> bytes = new List <byte>();
bytes.AddRange(Encoding.Default.GetBytes(Description));
bytes.Add(0x00);
bytes.AddRange(Value);
return(bytes.ToArray());
default:
throw new NotImplementedException("Writing " + version.ToString() + " has not been implemented!");
}
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
if (tagLength > 3)
{
long streamStart = stream.Position;
OwnerIdentifier = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Identifier = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Identifier, 0, Identifier.Length).ConfigureAwait(false);
}
else
{
throw new ArgumentException("Frame has an invalid length", "frame");
}
}
/// <summary>
/// Convert the Popularimeterframe.
/// </summary>
/// <returns>a RawFrame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameOptions options = Descriptor.Options;
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteString(Email, Encoding.ASCII, true);
writer.WriteByte(Rating);
writer.WriteUInt64(PlayCounter);
payload = writer.ToArray();
}
RawFrame frame = RawFrame.CreateFrame(Descriptor.Id, options, payload, version);
return frame;
}
internal override byte[] GetContentBytes(TagVersion version)
{
List<byte> bytes = new List<byte>();
switch (version)
{
case TagVersion.V23:
bytes.AddRange(Encoding.Default.GetBytes(OwnerIdentifier));
bytes.Add(0x00);
bytes.AddRange(Identifier);
break;
case TagVersion.V24:
default:
throw new ArgumentException("Version " + version.ToString() + " is not supported for this frame!", nameof(version));
}
return bytes.ToArray();
}
/// <summary>
/// Convert the values to a raw frame.
/// </summary>
/// <returns>the raw frame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameFlags flag = Descriptor.GetFlags();
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteEncodingByte(TextEncoding);
writer.WritePreamble(TextEncoding);
writer.WriteString(Description, TextEncoding, true);
writer.WriteString(URL, Encoding.GetEncoding(28591));
payload = writer.ToArray();
}
return RawFrame.CreateFrame(Descriptor.ID, flag, payload, version);
}
internal override byte[] GetContentBytes(TagVersion version)
{
List<byte> bytes = new List<byte>();
bytes.Add(0x00);
bytes.AddRange(System.Text.Encoding.Default.GetBytes(this.MimeType));
bytes.Add(0x00);
bytes.Add((byte)this.PictureType);
if (!String.IsNullOrEmpty(this.Description))
{
bytes.AddRange(System.Text.Encoding.Default.GetBytes(this.Description));
}
bytes.Add(0x00);
bytes.AddRange(this.Data);
return bytes.ToArray();
}
/// <summary>
/// Convert the values to a raw frame.
/// </summary>
/// <returns>the raw frame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameFlags flags = Descriptor.GetFlags();
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteEncodingByte(TextEncoding);
writer.WriteString(Language, Encoding.ASCII, 3);
writer.WritePreamble(TextEncoding);
writer.WriteString(ContentDescriptor, TextEncoding, true);
writer.WriteString(Text, TextEncoding);
payload = writer.ToArray();
}
return RawFrame.CreateFrame(Descriptor.ID, flags, payload, version);
}
/*
internal static RawFrame CreateV4Frame(string frameID, FrameFlags flags, byte[] payload)
{
var f = new RawFrameV4(frameID, flags, payload);
return f;
}
*/
internal static RawFrame CreateFrame(string frameID, FrameFlags flags, byte[] payload, TagVersion version)
{
RawFrame frame;
switch (version)
{
case TagVersion.Id3V23:
frame = new RawFrameV3(frameID, flags, payload);
break;
case TagVersion.Id3V24:
frame = new RawFrameV4(frameID, flags, payload);
break;
default:
throw new ID3TagException("Unknown Tag Version found!");
}
return frame;
}
/// <summary>
/// Called when receiving updates about the Tag informations
/// such as battery update, or status change
/// </summary>
/// <param name="status">Status.</param>
/// <param name="battery">Battery.</param>
/// <param name="version">Version.</param>
public virtual void UpdateTagInformations(string status_, int battery_, string version_)
{
if (status != status_)
{
// At start if not tracking the status is "unassigned"
if (status_ == "unassigned" && OnTrackingLost != null)
{
OnTrackingLost();
}
else if (status_ == "lost" && OnTrackingLost != null)
{
OnTrackingLost();
}
else if (status_ == "tracking" && OnTrackingLost != null)
{
OnTrackingFound();
}
status = status_;
}
battery = battery_;
if (version != version_)
{
if (version_.StartsWith("2", StringComparison.InvariantCulture))
{
tagVersion = TagVersion.V2;
}
else if (version_.StartsWith("3", StringComparison.InvariantCulture))
{
tagVersion = TagVersion.V3;
}
else if (version_.StartsWith("6", StringComparison.InvariantCulture))
{
tagVersion = TagVersion.Gun;
}
else
{
Debug.LogWarning("Couldn't determine the Tag version of " + version_ + " for tag UID " + UID);
}
version = version_;
}
}
internal override byte[] GetContentBytes(TagVersion version)
{
List <byte> bytes = new List <byte>();
bytes.Add(0x00);
bytes.AddRange(System.Text.Encoding.Default.GetBytes(this.MimeType));
bytes.Add(0x00);
bytes.Add((byte)this.PictureType);
if (!String.IsNullOrEmpty(this.Description))
{
bytes.AddRange(System.Text.Encoding.Default.GetBytes(this.Description));
}
bytes.Add(0x00);
bytes.AddRange(this.Data);
return(bytes.ToArray());
}
internal override byte[] GetContentBytes(TagVersion version)
{
List <byte> bytes = new List <byte>();
switch (version)
{
case TagVersion.V23:
bytes.AddRange(Encoding.Default.GetBytes(OwnerIdentifier));
bytes.Add(0x00);
bytes.AddRange(Identifier);
break;
case TagVersion.V24:
default:
throw new ArgumentException("Version " + version.ToString() + " is not supported for this frame!", nameof(version));
}
return(bytes.ToArray());
}
/// <summary>
/// Converts the picture frame to a raw frame.
/// </summary>
/// <returns>the raw frame.</returns>
public override RawFrame Convert(TagVersion version)
{
FrameFlags flag = Descriptor.GetFlags();
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteEncodingByte(TextEncoding);
writer.WriteString(MimeType, Encoding.ASCII, true);
writer.WriteByte((byte)PictureCoding);
writer.WritePreamble(TextEncoding);
writer.WriteString(Description, TextEncoding, true);
writer.WriteBytes(PictureData);
payload = writer.ToArray();
}
return RawFrame.CreateFrame("APIC", flag, payload, version);
}
/// <summary>
/// Creates a new ID3 Tag representation.
/// </summary>
/// <param name="version">the ID3 Tag version.</param>
/// <returns>the representation instance.</returns>
public static TagContainer CreateId3Tag(TagVersion version)
{
TagContainer container;
switch (version)
{
case TagVersion.Id3V23:
container = new TagContainerV3();
break;
case TagVersion.Id3V24:
container = new TagContainerV4();
break;
default:
throw new ID3TagException("Invalid tag version!");
}
return container;
}
/*
internal static RawFrame CreateV4Frame(string frameID, FrameOptions flags, byte[] payload)
{
var f = new RawFrameV4(frameID, flags, payload);
return f;
}
*/
internal static RawFrame CreateFrame(string frameId, FrameOptions options, IList<byte> payload,
TagVersion version)
{
RawFrame frame;
switch (version)
{
case TagVersion.Id3V23:
frame = new RawFrameV3(frameId, options, payload);
break;
case TagVersion.Id3V24:
frame = new RawFrameV4(frameId, options, payload);
break;
default:
throw new Id3TagException("Unknown Tag Version found!");
}
return frame;
}
/// <summary>
/// Creates a new ID3 Tag representation.
/// </summary>
/// <param name="version">the ID3 Tag version.</param>
/// <returns>the representation instance.</returns>
public static TagContainer CreateId3Tag(TagVersion version)
{
Logger.LogInfo(string.Format("Create ID3Tag with TagVersion {0}", version));
TagContainer container;
switch (version)
{
case TagVersion.Id3V23:
container = new TagContainerV3();
break;
case TagVersion.Id3V24:
container = new TagContainerV4();
break;
default:
throw new Id3TagException("Invalid tag version!");
}
return container;
}
/// <summary>
/// Convert the frame to raw frame.
/// </summary>
/// <returns>the raw frame</returns>
public override RawFrame Convert(TagVersion version)
{
/*
<Header for 'Unique file identifier', ID: "UFID">
Owner identifier: <text string> $00
Identifier: <up to 64 bytes binary data>
*/
FrameOptions options = Descriptor.Options;
byte[] payload;
using (var writer = new FrameDataWriter())
{
writer.WriteString(Owner, Encoding.GetEncoding(28591), true);
writer.WriteBytes(Identifier);
payload = writer.ToArray();
}
return RawFrame.CreateFrame(Descriptor.Id, options, payload, version);
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
switch (version)
{
case TagVersion.V23:
if (tagLength > 1)
{
long streamStart = stream.Position;
Description = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Value = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Value, 0, Value.Length).ConfigureAwait(false);
}
else
{
throw new ArgumentException("frame does not contain valid data!", "frame");
}
break;
default:
throw new NotImplementedException("Reading " + version.ToString() + " has not been implemented!");
}
}
public async Task Write(Stream stream, TagVersion version)
{
using (var memoryStream = new MemoryStream())
{
foreach (Frame id3Frame in Frames)
{
await id3Frame.WriteAsync(memoryStream, version).ConfigureAwait(false);
}
await stream.WriteAsync(Constants.ID3Header, 0, Constants.ID3Header.Length).ConfigureAwait(false);
switch (version)
{
case TagVersion.V22:
stream.WriteByte(0x02);
break;
case TagVersion.V23:
stream.WriteByte(0x03);
break;
case TagVersion.V24:
stream.WriteByte(0x04);
break;
default:
throw new ArgumentException("Unable to write ID3 Tag with version = " + version.ToString(), nameof(version));
}
stream.WriteByte(0x00);
stream.WriteByte(0x00);
long size = memoryStream.Length;
stream.WriteByte((byte)(size / (128 * 128 * 128)));
stream.WriteByte((byte)((size % (128 * 128 * 128)) / (128 * 128)));
stream.WriteByte((byte)((size % (128 * 128)) / 128));
stream.WriteByte((byte)(size % 128));
await memoryStream.CopyToAsync(stream).ConfigureAwait(false);
}
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
switch (version)
{
case TagVersion.V23:
if (tagLength > 1)
{
long streamStart = stream.Position;
Description = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Value = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Value, 0, Value.Length).ConfigureAwait(false);
}
else
{
throw new ArgumentException("frame does not contain valid data!", "frame");
}
break;
default:
throw new NotImplementedException("Reading " + version.ToString() + " has not been implemented!");
}
}
internal override byte[] GetContentBytes(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
var bytes = new List <byte>();
if (Encoding == Encoding.GetEncoding("ISO-8859-1"))
{
bytes.Add(0x00);
if (!string.IsNullOrEmpty(Text))
{
bytes.AddRange(Encoding.GetBytes(Text));
}
bytes.Add(0x00);
}
else if (Encoding == Encoding.Unicode || Encoding == Encoding.BigEndianUnicode)
{
bytes.Add(0x01);
if (!string.IsNullOrEmpty(Text))
{
bytes.AddRange(Encoding.GetPreamble());
bytes.AddRange(Encoding.GetBytes(Text));
}
bytes.Add(0x00);
bytes.Add(0x00);
}
else
{
throw new InvalidOperationException("Unknown encoding!");
}
return(bytes.ToArray());
default:
throw new NotImplementedException("Writing " + version.ToString() + " has not been implemented!");
}
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
long streamStart = stream.Position;
int encoding = stream.ReadByte();
switch (version)
{
case TagVersion.V24:
case TagVersion.V23:
if (encoding == 0x00)
{
MimeType = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
PictureType = (AttachedPictureType)stream.ReadByte();
Description = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Data = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Data, 0, Data.Length).ConfigureAwait(false);
}
else if (encoding == 0x01)
{
MimeType = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
PictureType = (AttachedPictureType)stream.ReadByte();
Description = await stream.ReadUnicodeStringAsync(streamStart + tagLength).ConfigureAwait(false);
Data = new byte[tagLength - (stream.Position - streamStart)];
await stream.ReadAsync(Data, 0, Data.Length).ConfigureAwait(false);
}
break;
default:
Debug.WriteLine("APIC: Version not implemented - " + version.ToString());
break;
}
}
public async Task Write(Stream stream, TagVersion version)
{
using (var memoryStream = new MemoryStream())
{
foreach (Frame id3Frame in Frames)
{
await id3Frame.WriteAsync(memoryStream, version).ConfigureAwait(false);
}
await stream.WriteAsync(Constants.ID3Header, 0, Constants.ID3Header.Length).ConfigureAwait(false);
switch (version)
{
case TagVersion.V22:
stream.WriteByte(0x02);
break;
case TagVersion.V23:
stream.WriteByte(0x03);
break;
case TagVersion.V24:
stream.WriteByte(0x04);
break;
default:
throw new ArgumentException("Unable to write ID3 Tag with version = " + version.ToString(), nameof(version));
}
stream.WriteByte(0x00);
stream.WriteByte(0x00);
long size = memoryStream.Length;
stream.WriteByte((byte)(size / (128 * 128 * 128)));
stream.WriteByte((byte)((size % (128 * 128 * 128)) / (128 * 128)));
stream.WriteByte((byte)((size % (128 * 128)) / 128));
stream.WriteByte((byte)(size % 128));
await memoryStream.CopyToAsync(stream).ConfigureAwait(false);
}
}
public override async Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version)
{
if (tagLength > 6)
{
long streamStart = stream.Position;
int encoding = stream.ReadByte();
var languageBytes = new byte[3];
await stream.ReadAsync(languageBytes, 0, languageBytes.Length).ConfigureAwait(false);
Language = Encoding.Default.GetString(languageBytes);
switch (encoding)
{
case 0x00:
Description = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
Text = await stream.ReadAnsiString(streamStart + tagLength).ConfigureAwait(false);
break;
case 0x01:
Description = await stream.ReadUnicodeStringAsync(streamStart + tagLength).ConfigureAwait(false);
Text = await stream.ReadUnicodeStringAsync(streamStart + tagLength).ConfigureAwait(false);
break;
default:
throw new ArgumentException("Frame has an invalid encoding marker", nameof(stream));
}
}
}
internal override byte[] GetContentBytes(TagVersion version)
{
switch (version)
{
case TagVersion.V23:
var bytes = new List<byte>();
if (Encoding == Encoding.GetEncoding("ISO-8859-1"))
{
bytes.Add(0x00);
if (!string.IsNullOrEmpty(Text))
{
bytes.AddRange(Encoding.GetBytes(Text));
}
bytes.Add(0x00);
}
else if (Encoding == Encoding.Unicode || Encoding == Encoding.BigEndianUnicode)
{
bytes.Add(0x01);
if (!string.IsNullOrEmpty(Text))
{
bytes.AddRange(Encoding.GetPreamble());
bytes.AddRange(Encoding.GetBytes(Text));
}
bytes.Add(0x00);
bytes.Add(0x00);
}
else
{
throw new InvalidOperationException("Unknown encoding!");
}
return bytes.ToArray();
default:
throw new NotImplementedException("Writing " + version.ToString() + " has not been implemented!");
}
}
internal override string GetTagId(TagVersion version) => "UFID";
/// <summary> /// Returns the frames string ID depending on the tag version (if applicable) /// </summary> /// <param name="version">The TagVersion requested</param> /// <returns>A string corresponding to the Frame ID</returns> internal abstract string GetTagId(TagVersion version);
public abstract Task FromStreamAsync(Stream stream, uint tagLength, TagVersion version);
/// <summary> /// Returns the frame's contents as a byte array. /// </summary> /// <returns>The frame content as an array of bytes</returns> internal abstract byte[] GetContentBytes(TagVersion version);
/// <summary> /// Convert the values from the high level frame to a raw frame. /// </summary> /// <returns>the raw frame.</returns> public abstract RawFrame Convert(TagVersion version);
internal override string GetTagId(TagVersion version) => "PRIV";
public Task SaveAsync(bool keepV1Tag = false, TagVersion version = TagVersion.V23) => SaveAsAsync(OriginalFile, keepV1Tag, version);
internal override string GetTagId(TagVersion version) => "TXXX";
