private void WriteTagContainer(TagContainer tagContainer)
{
Stream dataStream = null;
Stream tagStream = null;
try
{
dataStream = new MemoryStream(m_AudioData);
tagStream = new MemoryStream(64000);
// Write the content to a byte stream.
m_Controller.Write(tagContainer, dataStream, tagStream);
}
finally
{
if (dataStream != null)
{
dataStream.Close();
dataStream.Dispose();
}
if (tagStream != null)
{
tagStream.Close();
tagStream.Dispose();
}
}
}
public override bool Validate(TagContainer container)
{
if (container.Tag.MajorVersion == 3 && container.Tag.Revision == 0)
{
var valid = true;
foreach (var frame in container)
{
/*
* T___
* TXXX
* WXXX
* APIC
*
* fehlt noch:
* IPLS
* USLT
* SYLT
* COMM
* GEOB
* USER
* OWNE
* COMR
*
*/
switch (frame.Type)
{
case FrameType.Text:
valid = ValidateTextFrame(frame);
break;
case FrameType.UserDefinedText:
valid = ValidateUserDefinedTextFrame(frame);
break;
case FrameType.UserDefindedURLLink:
valid = ValidateUserDefinedLink(frame);
break;
case FrameType.Picture:
valid = ValidatePictureFrame(frame);
break;
}
if (!valid)
{
//
// Abort. Invalid frame found!
//
FailureDescription = String.Format("Frame {0} is not valid! (must be 3.0)", frame.Descriptor.ID);
break;
}
}
return valid;
}
else
{
FailureDescription = "The ID3 header version does not match!";
return false;
}
}
public void ExtendedHeaderEncoderTest()
{
var crc = new byte[] {0x20, 0x21, 0x22, 0x23};
var tagContainer = new TagContainer();
tagContainer.Tag.SetHeaderFlags(true, true, true);
tagContainer.Tag.SetVersion(3, 0);
tagContainer.Tag.SetExtendedHeader(10, true);
tagContainer.Tag.SetCrc32(crc);
var titleFrame = new TextFrame();
titleFrame.TextEncoding = TextEncodingType.UTF16;
titleFrame.Descriptor.ID = "TIT2";
titleFrame.Content = "ABCD";
tagContainer.Add(titleFrame);
var id3Tag = m_TagController.Encode(tagContainer);
Assert.AreEqual(id3Tag.MajorVersion, 3);
Assert.AreEqual(id3Tag.Revision, 0);
Assert.IsTrue(id3Tag.UnsynchronisationFlag);
Assert.IsTrue(id3Tag.UnsynchronisationFlag);
Assert.IsTrue(id3Tag.ExtendedHeaderAvailable);
Assert.IsNotNull(id3Tag.ExtendHeaderV3);
Assert.IsTrue(ComparePayload(id3Tag.ExtendHeaderV3.CRC, crc));
Assert.AreEqual(id3Tag.Frames.Count, 1);
}
private TagContainer WriteAndRead(TagContainer tagContainer1)
{
TagContainer tagContainer2;
Stream dataStream = null;
Stream tagStream = null;
try
{
dataStream = new MemoryStream(m_AudioData);
tagStream = new MemoryStream(64000);
// Write the content to a byte stream.
m_Controller.Write(tagContainer1, dataStream, tagStream);
// Read the bytes again
tagStream.Position = 0;
Id3TagInfo Id3TagInfo = m_Controller.Read(tagStream);
tagContainer2 = m_TagController.Decode(Id3TagInfo);
}
finally
{
if (dataStream != null)
{
dataStream.Close();
dataStream.Dispose();
}
if (tagStream != null)
{
tagStream.Close();
tagStream.Dispose();
}
}
return tagContainer2;
}
public void ValidationOKTest1()
{
/*
* T___
* TXXX
* WXXX
* APIC
*/
var tagContainer = new TagContainer();
tagContainer.Tag.SetExtendedHeader(0, false);
tagContainer.Tag.SetHeaderFlags(false, false, false);
tagContainer.Tag.SetVersion(3, 0);
var textFrame = new TextFrame("TALB", "My Albun", TextEncodingType.UTF16);
var userDefineTextFrame = new UserDefinedTextFrame("my comment", "so", TextEncodingType.UTF16);
var linkFrame = new UserDefinedURLLinkFrame("id3tag", "id3tag.codeplex.com", TextEncodingType.UTF16);
var pictureFrame = new PictureFrame(TextEncodingType.UTF16, "image/jpeg", "la", PictureType.Other,
new byte[] { 0x11, 0x12, 0x13, 0x14 });
tagContainer.Add(textFrame);
tagContainer.Add(userDefineTextFrame);
tagContainer.Add(linkFrame);
tagContainer.Add(pictureFrame);
WriteTagContainer(tagContainer);
// OK... passed!
}
public Id3TagInfo Encode(TagContainer container)
{
var tagInfo = new Id3TagInfo();
switch (container.TagVersion)
{
case TagVersion.Id3V23:
tagInfo.MajorVersion = 3;
tagInfo.Revision = 0;
EncodeV3(tagInfo, container);
break;
case TagVersion.Id3V24:
tagInfo.MajorVersion = 4;
tagInfo.Revision = 0;
EncodeV4(tagInfo, container);
break;
default:
var ex = new Id3TagException("Unknown version!");
Logger.LogError(ex);
throw ex;
}
foreach (IFrame frame in container)
{
RawFrame rawFrame = frame.Convert(container.TagVersion);
tagInfo.Frames.Add(rawFrame);
}
return tagInfo;
}
public void EncodeWithExtendedHeaderTest2()
{
//
// Configure the tag
//
var tagContainer1 = new TagContainer();
tagContainer1.Tag.SetVersion(3, 0);
tagContainer1.Tag.SetHeaderFlags(true, true, true);
tagContainer1.Tag.SetExtendedHeader(10, true);
tagContainer1.Tag.SetCrc32(new byte[] {0x10, 0x20, 0x30, 0x40});
var titleFrame = new TextFrame
{
Descriptor = {ID = "TIT2"},
TextEncoding = TextEncodingType.UTF16,
Content = "Title1"
};
tagContainer1.Add(titleFrame);
//
// Write and read the tag again.
//
var tagContainer2 = WriteAndRead(tagContainer1);
//
// Compare both container!
//
CompareContainer(tagContainer1, tagContainer2);
}
public override bool Validate(TagContainer container)
{
if (container.TagVersion == TagVersion.Id3V23)
{
bool valid = true;
foreach (IFrame frame in container)
{
//
// If the frame is a type of EncodedTextFrame then validate the coding
//
var textFrame = frame as EncodedTextFrame;
if (textFrame != null)
{
valid = ValidateTextEncoding(textFrame.TextEncoding);
}
if (!valid)
{
//
// Abort. Invalid frame found!
//
FailureDescription = String.Format(
CultureInfo.InvariantCulture, "Frame {0} uses an invalid text coding.", frame.Descriptor.Id);
break;
}
}
return valid;
}
FailureDescription = "The ID3 header version does not match!";
return false;
}
public override bool Validate(TagContainer container)
{
if (container.TagVersion != TagVersion.Id3V24)
{
FailureDescription = "No ID3v2.4 format.";
return false;
}
return true;
}
private static void CompareContainer(TagContainer c1, TagContainer c2)
{
Assert.AreEqual(c1.Count, c2.Count);
Assert.AreEqual(c1.Tag.MajorVersion, c2.Tag.MajorVersion);
Assert.AreEqual(c1.Tag.Revision, c2.Tag.Revision);
Assert.AreEqual(c1.Tag.ExperimentalIndicator, c2.Tag.ExperimentalIndicator);
Assert.AreEqual(c1.Tag.ExtendedHeader, c2.Tag.ExtendedHeader);
Assert.AreEqual(c1.Tag.Unsynchronisation, c2.Tag.Unsynchronisation);
Assert.AreEqual(c1.Tag.CrcDataPresent, c2.Tag.CrcDataPresent);
Assert.IsTrue(ComparePayload(c1.Tag.Crc, c2.Tag.Crc));
Assert.AreEqual(c1.Tag.PaddingSize, c2.Tag.PaddingSize);
}
/// <summary>
/// Writes a tag to file.
/// </summary>
/// <param name="tagContainer"></param>
/// <param name="sourceFile">the source file.</param>
/// <param name="targetFile">the target file.</param>
/// <remarks>the old tags will be removed.</remarks>
public void WriteTag(TagContainer tagContainer, string sourceFile, string targetFile)
{
try
{
Id3TagFactory.CreateId3TagManager().WriteV2Tag(sourceFile, targetFile, tagContainer);
}
catch (Id3IOException ioException)
{
MessageBox.Show("IO Exception caught : " + ioException.Message);
}
catch (Id3TagException tagException)
{
MessageBox.Show("Id3TagException caught : " + tagException.Message);
}
catch (Exception ex)
{
MessageBox.Show("Unknown exception caught : " + ex.Message);
}
}
public TagContainer Decode(Id3TagInfo info)
{
var container = new TagContainer();
var descriptor = container.Tag;
// Decode the ID3 Tag info
var majorVersion = info.MajorVersion;
var revision = info.Revision;
descriptor.SetVersion(majorVersion, revision);
descriptor.SetHeaderFlags(info.UnsynchronisationFlag, info.ExtendedHeaderAvailable, info.Experimental);
if (info.ExtendedHeaderAvailable)
{
var extendedHeader = info.ExtendHeaderV3;
descriptor.SetExtendedHeader(extendedHeader.PaddingSize, extendedHeader.CRCDataPresent);
if (extendedHeader.CRCDataPresent)
{
descriptor.SetCrc32(extendedHeader.CRC);
}
}
foreach (var rawFrame in info.Frames)
{
//
// Analyse the frame ID
//
var frame = AnalyseFrameId(rawFrame);
if (frame != null)
{
frame.Import(rawFrame);
container.Add(frame);
}
else
{
throw new ID3TagException("Frame analysing failed!");
}
}
return container;
}
/// <summary>
/// Writes a tag to file.
/// </summary>
/// <param name="tagController"></param>
/// <param name="sourceFile">the source file.</param>
/// <param name="targetFile">the target file.</param>
/// <remarks>the old tags will be removed.</remarks>
public void WriteTag(TagContainer tagController, string sourceFile, string targetFile)
{
FileStream inputStream = null;
FileStream outputStream = null;
try
{
var ioController = Id3TagFactory.CreateIoController();
// Write the tag.
inputStream = File.Open(sourceFile, FileMode.Open);
outputStream = File.OpenWrite(targetFile);
ioController.Write(tagController, inputStream, outputStream);
}
catch (ID3IOException ioException)
{
MessageBox.Show("IO Exception caught : " + ioException.Message);
}
catch (ID3TagException tagException)
{
MessageBox.Show("ID3TagException caught : " + tagException.Message);
}
catch (Exception ex)
{
MessageBox.Show("Unknown exception caught : " + ex.Message);
}
finally
{
if (inputStream != null)
{
inputStream.Close();
inputStream.Dispose();
}
if (outputStream != null)
{
outputStream.Close();
outputStream.Dispose();
}
}
}
public void SimpleEncoderTest()
{
var tagContainer = new TagContainer();
tagContainer.Tag.SetHeaderFlags(false, false, false);
tagContainer.Tag.SetVersion(3, 0);
var titleFrame = new TextFrame();
titleFrame.TextEncoding = TextEncodingType.UTF16;
titleFrame.Descriptor.ID = "TIT2";
titleFrame.Content = "ABCD";
tagContainer.Add(titleFrame);
var id3Tag = m_TagController.Encode(tagContainer);
Assert.AreEqual(id3Tag.MajorVersion, 3);
Assert.AreEqual(id3Tag.Revision, 0);
Assert.IsFalse(id3Tag.UnsynchronisationFlag);
Assert.IsFalse(id3Tag.UnsynchronisationFlag);
Assert.IsFalse(id3Tag.ExtendedHeaderAvailable);
Assert.IsNull(id3Tag.ExtendHeaderV3);
Assert.AreEqual(id3Tag.Frames.Count, 1);
}
public Id3TagInfo Encode(TagContainer container)
{
var tagInfo = new Id3TagInfo();
var tag = container.Tag;
tagInfo.MajorVersion = tag.MajorVersion;
tagInfo.Revision = tag.Revision;
tagInfo.Experimental = tag.ExperimentalIndicator;
tagInfo.UnsynchronisationFlag = tag.Unsynchronisation;
tagInfo.ExtendedHeaderAvailable = tag.ExtendedHeader;
if (tagInfo.ExtendedHeaderAvailable)
{
tagInfo.ExtendHeaderV3 = ExtendedTagHeaderV3.Create(tag.PaddingSize, tag.CrcDataPresent, tag.Crc);
}
foreach (var frame in container)
{
var rawFrame = frame.Convert();
tagInfo.Frames.Add(rawFrame);
}
return tagInfo;
}
private static bool ValidateTag(TagContainer tagContainer, out string message)
{
Validator validator;
switch (tagContainer.TagVersion)
{
case TagVersion.Id3V23:
validator = new Id3V2Validator();
break;
case TagVersion.Id3V24:
validator = new Id3V24Validator();
break;
default:
throw new ID3TagException("Unknown version!");
}
var isValid = validator.Validate(tagContainer);
if (isValid)
{
message = String.Empty;
}
else
{
message = validator.FailureDescription;
}
return isValid;
}
private static byte[] GetFrameBytes(TagContainer tagContainer)
{
var listBytes = new List<byte>();
foreach (var frame in tagContainer)
{
var rawFrame = frame.Convert(tagContainer.TagVersion);
var headerBytes = new byte[10];
var idBytes = rawFrame.GetIDBytes();
var lengthBytes = BitConverter.GetBytes(rawFrame.Payload.Length);
// Convert from LSB to MSB. Better way here??
Array.Reverse(lengthBytes);
var flagsBytes = rawFrame.EncodeFlags();
Array.Copy(idBytes, 0, headerBytes, 0, 4);
Array.Copy(lengthBytes, 0, headerBytes, 4, 4);
Array.Copy(flagsBytes, 0, headerBytes, 8, 2);
listBytes.AddRange(headerBytes);
listBytes.AddRange(rawFrame.Payload);
}
return listBytes.ToArray();
}
private static byte[] GetTagHeader(TagContainer tagContainer)
{
var tagHeader = new byte[10];
tagHeader[0] = 0x49;
tagHeader[1] = 0x44;
tagHeader[2] = 0x33;
switch (tagContainer.TagVersion)
{
case TagVersion.Id3V23:
var descriptorV3 = tagContainer.GetId3V23Descriptor();
tagHeader[3] = 0x03;
tagHeader[4] = 0x00;
if (descriptorV3.Unsynchronisation)
{
tagHeader[5] |= 0x80;
}
if (descriptorV3.ExtendedHeader)
{
tagHeader[5] |= 0x40;
}
if (descriptorV3.ExperimentalIndicator)
{
tagHeader[5] |= 0x20;
}
break;
case TagVersion.Id3V24:
var descriptorV4 = tagContainer.GetId3V24Descriptor();
tagHeader[3] = 0x04;
tagHeader[4] = 0x00;
if (descriptorV4.Unsynchronisation)
{
tagHeader[5] |= 0x80;
}
if (descriptorV4.ExtendedHeader)
{
tagHeader[5] |= 0x40;
}
if (descriptorV4.ExperimentalIndicator)
{
tagHeader[5] |= 0x20;
}
if (descriptorV4.Footer)
{
tagHeader[5] |= 0x10;
}
break;
default:
throw new ID3TagException("Unknown version!");
}
return tagHeader;
}
private static byte[] GetExtendedHeaderV3(TagContainer tagContainer)
{
var extendedHeaderBytes = new byte[0];
var tag = tagContainer.GetId3V23Descriptor();
if (tag.ExtendedHeader)
{
var extendedHeaderLength = 0;
if (tag.CrcDataPresent)
{
extendedHeaderLength = 10;
}
else
{
extendedHeaderLength = 6;
}
// Create and set the length
extendedHeaderBytes = new byte[extendedHeaderLength + 4];
extendedHeaderBytes[3] = Convert.ToByte(extendedHeaderLength);
var paddingBytes = BitConverter.GetBytes(tag.PaddingSize);
Array.Reverse(paddingBytes);
Array.Copy(paddingBytes, 0, extendedHeaderBytes, 6, 4);
if (tag.CrcDataPresent)
{
extendedHeaderBytes[4] |= 0x80;
Array.Copy(tag.Crc, 0, extendedHeaderBytes, 10, 4);
}
}
return extendedHeaderBytes;
}
private static byte[] BuildId3V3Tag(TagContainer tagContainer)
{
byte[] tagBytes;
var tag = tagContainer.GetId3V23Descriptor();
var frameBytes = GetFrameBytes(tagContainer);
//
// Calculate the CRC32 value of the frameBytes ( before unsync!)
//
if (tag.CrcDataPresent)
{
var crc32 = new Crc32(Crc32.DefaultPolynom);
var crcValue = crc32.Calculate(frameBytes);
tag.SetCrc32(crcValue);
}
//
// OK. Build the complete tag
//
var extendedHeaderBytes = GetExtendedHeaderV3(tagContainer);
var tagHeader = GetTagHeader(tagContainer);
var rawTagBytes = BuildFinalTag(tagHeader, extendedHeaderBytes, frameBytes, tag.PaddingSize, false);
if (tag.Unsynchronisation)
{
tagBytes = AddUnsyncBytes(rawTagBytes);
}
else
{
tagBytes = rawTagBytes;
}
return tagBytes;
}
private byte[] BuildId3V4Tag(TagContainer tagContainer)
{
byte[] tagBytes;
var tag = tagContainer.GetId3V24Descriptor();
var frameBytes = GetFrameBytes(tagContainer);
//TODO: Implement CRC32 code here...
var extendedHeaderBytes = GetExtendedHeaderV4(tag);
var tagHeader = GetTagHeader(tagContainer);
//TODO: Implement Unsync Code...
tagBytes = BuildFinalTag(tagHeader, extendedHeaderBytes, frameBytes, 0,tag.Footer);
return tagBytes;
}
public void Write(TagContainer tagContainer, Stream input, Stream output)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
if (output == null)
{
throw new ArgumentNullException("output");
}
if (tagContainer == null)
{
throw new ArgumentNullException("tagContainer");
}
//
// Validate whether the tag container is in ID3V2.3 formaz
//
string message;
var isTagValid = ValidateTag(tagContainer, out message);
if (!isTagValid)
{
throw new InvalidID3StructureException(message);
}
//
// OK. ID3Tag is valid. Let's write the tag.
//
byte[] tagBytes;
switch (tagContainer.TagVersion)
{
case TagVersion.Id3V23:
tagBytes = BuildId3V3Tag(tagContainer);
break;
case TagVersion.Id3V24:
tagBytes = BuildId3V4Tag(tagContainer);
break;
default:
throw new ID3TagException("This TagVersion is not supported!");
}
//
// encode the length
//
long length;
if (tagContainer.TagVersion == TagVersion.Id3V24)
{
var descriptor = tagContainer.GetId3V24Descriptor();
if (descriptor.Footer)
{
length = tagBytes.LongLength - 20;
}
else
{
length = tagBytes.LongLength - 10;
}
}
else
{
length = tagBytes.LongLength - 10;
}
var bits = GetBitCoding(length);
var lengthBytes = new byte[4];
EncodeLength(bits, lengthBytes);
Array.Copy(lengthBytes, 0, tagBytes, 6, 4);
//
// Build the tag bytes and start writing.
//
if (!input.CanRead)
{
throw new ID3IOException("Cannot read input stream");
}
if (!output.CanWrite)
{
throw new ID3IOException("Cannot write to output stream");
}
WriteToStream(input, output, tagBytes);
}
private static void WriteUnsychronisedLyrics(string descriptor, string lyrics, TagContainer container)
{
var uslt = new UnsynchronisedLyricFrame("ENG",descriptor,lyrics,Encoding.ASCII);
container.Add(uslt);
}
/// <summary>
/// Fetches data from a FRED service endpoint.
/// </summary>
/// <returns>
/// A <see cref="TagContainer"/> containing FRED data.
/// An abnormal fetch returns null and a message is available in the <see cref="FetchMessage"/> property.
/// </returns>
public TagContainer Fetch()
{
TagContainer result = base.Fetch <TagContainer>();
return(result);
}
/// <summary>
/// Fetches data from a FRED service endpoint asynchronously.
/// </summary>
/// <returns>
/// A <see cref="TagContainer"/> containing FRED data.
/// An abnormal fetch returns null and a message is available in the <see cref="FetchMessage"/> property.
/// </returns>
public async Task <TagContainer> FetchAsync()
{
TagContainer result = await base.FetchAsync <TagContainer>();
return(result);
}
private static void EncodeV4(Id3TagInfo tagInfo, TagContainer container)
{
TagDescriptorV4 descriptor = container.GetId3V24Descriptor();
tagInfo.Experimental = descriptor.ExperimentalIndicator;
tagInfo.ExtendedHeaderAvailable = descriptor.ExtendedHeader;
tagInfo.Unsynchronised = descriptor.Unsynchronisation;
tagInfo.HasFooter = descriptor.Footer;
if (descriptor.ExtendedHeader)
{
tagInfo.ExtendedHeader = ExtendedTagHeaderV4.Create(descriptor.UpdateTag, descriptor.CrcDataPresent,
descriptor.RestrictionPresent,
descriptor.Restriction, descriptor.Crc);
}
}
public ZuneMP3TagContainer(TagContainer container,string filePath)
{
_container = container;
_filePath = filePath;
}
private static void EncodeV3(Id3TagInfo tagInfo, TagContainer container)
{
TagDescriptorV3 descriptor = container.GetId3V23Descriptor();
tagInfo.Experimental = descriptor.ExperimentalIndicator;
tagInfo.ExtendedHeaderAvailable = descriptor.ExtendedHeader;
tagInfo.Unsynchronised = descriptor.Unsynchronisation;
if (descriptor.ExtendedHeader)
{
tagInfo.ExtendedHeader = ExtendedTagHeaderV3.Create(descriptor.PaddingSize, descriptor.CrcDataPresent,
descriptor.Crc);
}
}
/// <summary>
/// Writes specified ID3 v2 tag to new file.
/// </summary>
/// <param name="sourcePath">The source file path.</param>
/// <param name="targetPath">The target file path.</param>
/// <param name="tag">The tag data.</param>
public void WriteV2Tag(string sourcePath, string targetPath, TagContainer tag)
{
#region Params Check
if (String.IsNullOrEmpty(sourcePath))
{
throw new ArgumentNullException("sourcePath");
}
if (!File.Exists(sourcePath))
{
throw new FileNotFoundException("File does not exist.", sourcePath);
}
if (String.IsNullOrEmpty(targetPath))
{
throw new ArgumentNullException("targetPath");
}
if (File.Exists(targetPath))
{
throw new FileNotFoundException("File already exists.", targetPath);
}
if (tag == null)
{
throw new ArgumentNullException("tag");
}
#endregion
IIOController controller = Id3TagFactory.CreateIOController();
WriteTag(sourcePath, targetPath, (input, output) => controller.Write(tag, input, output));
}
public abstract bool Validate(TagContainer container);
private static void WritePictureFrame(ID3V2TagData data, TagContainer container)
{
using (FileStream stream = File.Open(data.PictureFile, FileMode.Open))
{
//
// Read the picture.
//
int byteCount = Convert.ToInt32(stream.Length);
var pictureData = new byte[byteCount];
stream.Read(pictureData, 0, byteCount);
//
// Add the picture frame.
//
var pictureFrame = new PictureFrame(
Encoding.Default,
"image/jpg",
"Other",
PictureType.Other,
pictureData);
container.Add(pictureFrame);
}
}
private void ShowTagFrames(TagContainer tagContainer)
{
//
// Iterate over the frame collection and show the ToString representation.
//
listView1Tags.Items.Clear();
foreach (var frame in tagContainer)
{
listView1Tags.Items.Add(frame.ToString());
}
}
public void Dispose()
{
TagContainer?.Dispose();
}
