////------------------------------------------------------------------------------------------------------------------------------ /// <inheritdoc /> public override byte[] ToByteArray() { using (StreamBuffer sb = new StreamBuffer()) { sb.Write(base.ToByteArray()); sb.WriteBigEndianBytes(UnencodedConstantValue, SampleSize / 8); return sb.ToByteArray(); } }
/// <summary> /// Returns the frame in a byte array. /// </summary> /// <returns>The frame in a byte array.</returns> public byte[] ToByteArray() { using (StreamBuffer buffer = new StreamBuffer()) { buffer.Write(_header); buffer.Write(AudioData); return buffer.ToByteArray(); } }
////------------------------------------------------------------------------------------------------------------------------------ /// <inheritdoc/> public byte[] ToByteArray() { using (StreamBuffer buffer = new StreamBuffer()) { buffer.Write(HeaderIdentifierBytes); if (Lyrics != null) buffer.WriteString(Lyrics, Encoding); buffer.Write(FooterIdentifierBytes); return buffer.ToByteArray(); } }
/// <summary> /// Places the <see cref="VorbisComment"/> into a byte array. /// </summary> /// <returns> /// A byte array that represents the <see cref="VorbisComment"/>. /// </returns> public byte[] ToByteArray() { using (StreamBuffer buf = new StreamBuffer()) { string val = (Name ?? String.Empty) + Delimiter + Value; buf.WriteInt(Encoding.UTF8.GetByteCount(val)); buf.WriteString(val, Encoding.UTF8); return buf.ToByteArray(); } }
////------------------------------------------------------------------------------------------------------------------------------ /// <summary> /// Writes the frame into a byte array. /// </summary> /// <returns> /// A byte array that represents the frame. /// </returns> public byte[] ToByteArray() { using (StreamBuffer sb = new StreamBuffer()) { sb.WriteString(Identifier, Encoding.ASCII, FieldIdentifierLength); byte[] data = Data; if (data != null) { sb.WriteString(data.Length.ToString("D" + FieldSizeLength, CultureInfo.InvariantCulture)); sb.Write(data); } else { sb.WriteString(0.ToString("D" + FieldSizeLength, CultureInfo.InvariantCulture)); } return sb.ToByteArray(); } }
////------------------------------------------------------------------------------------------------------------------------------ /// <summary> /// Places the <see cref="VorbisComments"/> into a byte array. /// </summary> /// <returns> /// A byte array that represents the <see cref="VorbisComments"/>. /// </returns> public byte[] ToByteArray() { using (StreamBuffer buf = new StreamBuffer()) { Vendor = Vendor ?? String.Empty; buf.WriteInt(Encoding.UTF8.GetByteCount(Vendor)); buf.WriteString(Vendor, Encoding.UTF8); buf.WriteInt(Comments.Count); foreach (byte[] data in Comments.Where(c => c != null).Select(c => c.ToByteArray())) { buf.WriteInt(data.Length); buf.Write(data); } return buf.ToByteArray(); } }
/// <summary> /// Returns the metadata block in a byte array. /// </summary> /// <returns>The frame in a byte array.</returns> public byte[] ToByteArray() { using (StreamBuffer buffer = new StreamBuffer()) { buffer.WriteBigEndianBytes(Flags, 1); buffer.WriteBigEndianBytes(Data.Length, 3); buffer.Write(Data); return buffer.ToByteArray(); } }
/// <inheritdoc /> public byte[] ToByteArray() { using (StreamBuffer sb = new StreamBuffer()) { sb.WriteString(Identifier); FlacStreamInfoMetadataBlock streamInfoMetadataBlock = StreamInfoMetadataBlocks.FirstOrDefault(); if (streamInfoMetadataBlock != null) sb.Write(streamInfoMetadataBlock.ToByteArray()); foreach (FlacMetadataBlock metadataBlock in MetadataBlocks.Where(m => !ReferenceEquals(m, streamInfoMetadataBlock))) sb.Write(metadataBlock.ToByteArray()); foreach (FlacFrame frame in Frames) sb.Write(frame.ToByteArray()); return sb.ToByteArray(); } }
////------------------------------------------------------------------------------------------------------------------------------ /// <summary> /// Writes the <see cref="Id3v2ReplayGain"/> into a byte array. /// </summary> /// <returns> /// A byte array that represents the <see cref="Id3v2ReplayGain"/> instance. /// </returns> public byte[] ToByteArray() { using (StreamBuffer stream = new StreamBuffer()) { int value = ((int)NameCode & NameCodeMask) << 13; value &= ((int)OriginatorCode & OriginatorCodeMask) << 10; value &= ((int)Sign & SignMask) << 9; value &= Adjustment & AdjustmentMask; stream.WriteShort((short)value); return stream.ToByteArray(); } }
////------------------------------------------------------------------------------------------------------------------------------ /// <inheritdoc /> public byte[] ToByteArray() { using (StreamBuffer buffer = new StreamBuffer()) { if (UseHeader) { // Header buffer.Write(HeaderIdentifierBytes); buffer.WritePadding(NullByte, 2); buffer.WriteString(XingEncoderVersion); buffer.WritePadding(NullByte, 2); buffer.WriteString(Version); buffer.WritePadding(NullByte, 2); buffer.WritePadding(PaddingByte, 226); } // Image extension int imageExtensionOffset = (int)buffer.Position; if ((Image != null) && !String.IsNullOrEmpty(Image.FileExtension)) { buffer.WriteString(Image.FileExtension); buffer.WritePadding(PaddingByte, 4 - Image.FileExtension.Length); } else buffer.WritePadding(PaddingByte, 4); // Image binary int imageBinaryOffset = (int)buffer.Position; if ((Image != null) && (Image.BinaryImage != null)) { buffer.WriteInt(Image.BinaryImage.Length); buffer.Write(Image.BinaryImage); } else buffer.WriteInt(0); // Unused int unusedOffset = (int)buffer.Position; buffer.WritePadding(NullByte, 4); // Version information int versionInfoOffset = (int)buffer.Position; buffer.WriteString(HeaderIdentifier); buffer.WritePadding(NullByte, 2); buffer.WriteString(XingEncoderVersion); buffer.WritePadding(NullByte, 2); buffer.WriteString(Version); buffer.WritePadding(NullByte, 2); buffer.WritePadding(PaddingByte, 226); // Audio meta-data // The audio meta-data is the heart of the MusicMatch tag. It contains most // of the pertinent information found in other tagging formats (song title, // album title, artist, etc.) and some that are unique to this format (mood, // preference, situation). int audioMetaDataOffset = (int)buffer.Position; // Single-line text fields buffer.WriteShort((short)(SongTitle ?? String.Empty).Length); buffer.WriteString(SongTitle ?? String.Empty); buffer.WriteShort((short)(AlbumTitle ?? String.Empty).Length); buffer.WriteString(AlbumTitle ?? String.Empty); buffer.WriteShort((short)(ArtistName ?? String.Empty).Length); buffer.WriteString(ArtistName ?? String.Empty); buffer.WriteShort((short)(Genre ?? String.Empty).Length); buffer.WriteString(Genre ?? String.Empty); buffer.WriteShort((short)(Tempo ?? String.Empty).Length); buffer.WriteString(Tempo ?? String.Empty); buffer.WriteShort((short)(Mood ?? String.Empty).Length); buffer.WriteString(Mood ?? String.Empty); buffer.WriteShort((short)(Situation ?? String.Empty).Length); buffer.WriteString(Situation ?? String.Empty); buffer.WriteShort((short)(Preference ?? String.Empty).Length); buffer.WriteString(Preference ?? String.Empty); // Non-text fields buffer.WriteShort((short)(SongDuration ?? String.Empty).Length); buffer.WriteString(SongDuration ?? String.Empty); buffer.WriteDouble(CreationDate.ToOADate()); buffer.WriteInt(PlayCounter); buffer.WriteShort((short)(OriginalFilename ?? String.Empty).Length); buffer.WriteString(OriginalFilename ?? String.Empty); buffer.WriteShort((short)(SerialNumber ?? String.Empty).Length); buffer.WriteString(SerialNumber ?? String.Empty); buffer.WriteShort(TrackNumber); // Multi-line text fields buffer.WriteShort((short)(Notes ?? String.Empty).Length); buffer.WriteString(Notes ?? String.Empty); buffer.WriteShort((short)(ArtistBio ?? String.Empty).Length); buffer.WriteString(ArtistBio ?? String.Empty); buffer.WriteShort((short)(Lyrics ?? String.Empty).Length); buffer.WriteString(Lyrics ?? String.Empty); // Internet addresses buffer.WriteShort((short)(ArtistUrl ?? String.Empty).Length); buffer.WriteString(ArtistUrl ?? String.Empty); buffer.WriteShort((short)(BuyCdUrl ?? String.Empty).Length); buffer.WriteString(BuyCdUrl ?? String.Empty); buffer.WriteShort((short)(ArtistEmail ?? String.Empty).Length); buffer.WriteString(ArtistEmail ?? String.Empty); // Null bytes buffer.WritePadding(NullByte, 16); // In all versions of the MusicMatch format up to and including 3.00, the // section is always 7868 bytes in length. All subsequent versions allowed // three possible lengths for this section: 7936, 8004, and 8132 bytes. The // conditions under which a particular length from these three possibilities // was used is unknown. In all cases, this section is padded with dashes // ($2D) to achieve this constant size. double version; if (!Double.TryParse(Version, out version)) version = 3.100000; // The padding is calculated by taking the AudioMetaDataSize minus the total size of audio meta data fields, // minus the total size of the data offset fields, minus the footer size. long paddingSize = ((version <= 3.1) ? AudioMetaDataSizes.First() : AudioMetaDataSizes.Last()) - (buffer.Length - audioMetaDataOffset) - DataOffsetFieldsSize - FooterSize; buffer.WritePadding(0x2D, (int)paddingSize); // Data offsets buffer.WriteInt(imageExtensionOffset); buffer.WriteInt(imageBinaryOffset); buffer.WriteInt(unusedOffset); buffer.WriteInt(versionInfoOffset); buffer.WriteInt(audioMetaDataOffset); // Footer buffer.Write(FooterIdentifierBytes); buffer.WritePadding(PaddingByte, 13); buffer.WriteString(Version.Substring(0 ,4)); buffer.WritePadding(PaddingByte, 12); return buffer.ToByteArray(); } }
/// <summary> /// Returns the frame in a byte array. /// </summary> /// <returns>The frame in a byte array.</returns> public virtual byte[] ToByteArray() { using (StreamBuffer sb = new StreamBuffer()) { sb.WriteBigEndianInt32(Header); sb.WriteUnaryInt(WastedBits); return sb.ToByteArray(); } }
////------------------------------------------------------------------------------------------------------------------------------ /// <inheritdoc/> /// <remarks> /// The extended tags will only be written when <see cref="UseExtendedTag"/> is set to true. /// </remarks> public byte[] ToByteArray() { using (StreamBuffer buffer = new StreamBuffer()) { byte[] byteValue; if (UseExtendedTag) { // TAG+ buffer.Write(ExtendedHeaderIdentifierBytes); // Title - write the last 60 bytes byteValue = _encoding.GetBytes(GetExtendedString(_trackTitle ?? String.Empty, 30, 60, true)); buffer.Write(byteValue); buffer.WritePadding(0x00, 60 - byteValue.Length); // Artist - write the last 60 bytes byteValue = _encoding.GetBytes(GetExtendedString(_artist ?? String.Empty, 30, 60, true)); buffer.Write(byteValue); buffer.WritePadding(0x00, 60 - byteValue.Length); // Album Title - write the last 60 bytes byteValue = _encoding.GetBytes(GetExtendedString(_albumTitle ?? String.Empty, 30, 60, true)); buffer.Write(byteValue); buffer.WritePadding(0x00, 60 - byteValue.Length); // Track Speed buffer.WriteByte((byte)_trackSpeed); // Extended Track Genre byteValue = _encoding.GetBytes(ExtendedTrackGenre ?? String.Empty); buffer.Write(byteValue); buffer.WritePadding(0x00, 30 - byteValue.Length); // Start-time long startTimeMinutes = (StartTime.Days * 24 * 60) + (StartTime.Hours * 60) + StartTime.Minutes; long startTimeSeconds = StartTime.Seconds; string startTime = startTimeMinutes.ToString("000") + ":" + startTimeSeconds.ToString("00"); byteValue = _encoding.GetBytes(GetTruncatedEncodedString(startTime, 6)); buffer.Write(byteValue); // End-time long endTimeMinutes = (EndTime.Days * 24 * 60) + (EndTime.Hours * 60) + EndTime.Minutes; long endTimeSeconds = EndTime.Seconds; string endTime = endTimeMinutes.ToString("000") + ":" + endTimeSeconds.ToString("00"); byteValue = _encoding.GetBytes(GetTruncatedEncodedString(endTime, 6)); buffer.Write(byteValue); } // TAG buffer.Write(HeaderIdentifierBytes); // Track Title byteValue = _encoding.GetBytes(GetTruncatedEncodedString(_trackTitle ?? String.Empty, 30)); buffer.Write(byteValue); buffer.WritePadding(0x00, 30 - byteValue.Length); // Artist byteValue = _encoding.GetBytes(GetTruncatedEncodedString(_artist ?? String.Empty, 30)); buffer.Write(byteValue); buffer.WritePadding(0x00, 30 - byteValue.Length); // Album Title byteValue = _encoding.GetBytes(GetTruncatedEncodedString(_albumTitle ?? String.Empty, 30)); buffer.Write(byteValue); buffer.WritePadding(0x00, 30 - byteValue.Length); // Album Year byteValue = _encoding.GetBytes(AlbumYear ?? String.Empty); buffer.Write(byteValue); buffer.WritePadding(0x00, 4 - byteValue.Length); // Track comment byteValue = _encoding.GetBytes(TrackComment ?? String.Empty); buffer.Write(byteValue); buffer.WritePadding(0x00, TrackCommentLength - byteValue.Length); // Track Number if (Version >= Id3v1Version.Id3v11) { buffer.WriteByte(0x00); buffer.WriteByte(TrackNumber); } // Genre buffer.WriteByte((byte)Genre); return buffer.ToByteArray(); } }
public void ToByteArrayTest() { byte[] value = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A }; StreamBuffer target = new StreamBuffer(value); byte[] expected = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A }; byte[] actual = target.ToByteArray(); Assert.IsTrue(actual.SequenceEqual(expected)); }
/// <inheritdoc/> public override byte[] ToByteArray() { using (StreamBuffer buf = new StreamBuffer()) { buf.WriteString(Name); buf.WriteBigEndianInt32(Flags); if ((Flags & XingHeaderFlags.FrameCountFlag) != 0) buf.WriteBigEndianInt32(FrameCount); if ((Flags & XingHeaderFlags.FileSizeFlag) != 0) buf.WriteBigEndianInt32(FileSize); // Extract TOC (Table of Contents) for more accurate seeking if ((Flags & XingHeaderFlags.TocFlag) != 0) { for (int i = 0; i < 100; i++) buf.WriteByte((byte)Toc[i]); } if ((Flags & XingHeaderFlags.VbrScaleFlag) != 0) buf.WriteBigEndianInt32(Quality); return buf.ToByteArray(); } }
/// <inheritdoc /> public byte[] ToByteArray() { using (StreamBuffer sb = new StreamBuffer()) { foreach (MpaFrame frame in Frames) sb.Write(frame.ToByteArray()); return sb.ToByteArray(); } }
/// <inheritdoc/> public override byte[] ToByteArray() { using (StreamBuffer buffer = new StreamBuffer()) { buffer.WriteString(Name); buffer.WriteBigEndianInt16(Version); buffer.WriteBigEndianInt16((short)_delay); buffer.WriteBigEndianInt16((short)Quality); buffer.WriteBigEndianInt32(FileSize); buffer.WriteBigEndianInt32(FrameCount); buffer.WriteBigEndianInt16(TableEntries); buffer.WriteBigEndianInt16(TableScale); buffer.WriteBigEndianInt16(TableEntrySize); buffer.WriteBigEndianInt16(FramesPerTableEntry); for (int i = 0; i <= TableEntries; i++) buffer.WriteBigEndianBytes(Toc[i] / TableScale, TableEntrySize); return buffer.ToByteArray(); } }
private bool ReadItem(ApeVersion version, int valueSize, StreamBuffer stream, long maximumItemSize) { if (stream == null) throw new ArgumentNullException("stream"); // Check if the item size indicated is really the size of the item. // Some files just aren't... properly written. byte[] data = new byte[valueSize]; int dataBytesRead = stream.Read(data, valueSize); int bytesLeftInStream = (int)(maximumItemSize - dataBytesRead); if ((valueSize > 0) && (bytesLeftInStream > 0) && (dataBytesRead >= valueSize)) { using (StreamBuffer dataBuffer = new StreamBuffer(data)) { // See if there's a next item. // Try to find the start of the next item. long startPositionNextItem = stream.Position; long bytesUntilNextItem = GetBytesUntilNextItem(version, stream, maximumItemSize - valueSize); stream.Position = startPositionNextItem; // Seems that the size indicated by the item is not the total size of the item; read the extra bytes here. if (bytesUntilNextItem > 0) { data = new byte[bytesUntilNextItem]; stream.Read(data, data.Length); dataBuffer.Write(data); } data = dataBuffer.ToByteArray(); } } Data = data; return true; }
/// <summary> /// Returns the frame in a byte array. /// </summary> /// <returns>The frame in a byte array.</returns> public byte[] ToByteArray() { using (StreamBuffer sb = new StreamBuffer()) { sb.WriteBigEndianInt32(_header); sb.Write(_sampleFrameNumberBytes); int blockSize = (_header >> 12) & 0xF; switch (blockSize) { case 0x06: sb.WriteByte((byte)(BlockSize - 1)); break; case 0x07: sb.WriteBigEndianInt16((short)(BlockSize - 1)); break; } int samplingRate = (_header >> 8) & 0xF; switch (samplingRate) { case 0x0C: sb.WriteByte((byte)(SamplingRate / 1000)); break; case 0x0D: sb.WriteBigEndianInt16((short)SamplingRate); break; case 0x0E: sb.WriteBigEndianInt16((short)(SamplingRate / 10)); break; } sb.WriteByte((byte)_crc8); foreach (FlacSubFrame subFrame in SubFrames) sb.Write(subFrame.ToByteArray()); sb.WriteBigEndianInt16((short)_crc16); return sb.ToByteArray(); } }
////------------------------------------------------------------------------------------------------------------------------------ /// <summary> /// Places the <see cref="LameTag"/> into a byte array. /// </summary> /// <returns>A byte array that represents the <see cref="LameTag"/> instance.</returns> public byte[] ToByteArray() { using (StreamBuffer buffer = new StreamBuffer()) { if (Version < 3.09f) { buffer.WriteString(EncoderVersion, Encoding.ASCII, 20); } else { buffer.WriteString(EncoderVersion, Encoding.ASCII, 9); buffer.WriteByte((byte)((InfoTagRevision & 0xF0) | (VbrMethod & 0x0F))); buffer.WriteByte((byte)LowpassFilterValue); buffer.WriteFloat(PeakSignalAmplitude); buffer.WriteShort(RadioReplayGain); buffer.WriteShort(AudiophileReplayGain); buffer.WriteByte((byte)EncodingFlags); buffer.WriteByte((byte)BitRate); buffer.WriteBytes(EncoderDelays, 3); buffer.WriteByte((byte)Misc); buffer.WriteByte((byte)Mp3Gain); buffer.WriteShort(PresetSurroundInfo); buffer.WriteBigEndianInt32(MusicLength); buffer.WriteBigEndianInt16(_musicCrc); buffer.WriteBigEndianInt16(_infoTagCrc); } return buffer.ToByteArray(); } }