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(); }