/// <summary>
/// Writes the size field for this frame to a stream.
/// </summary>
/// <param name="stream">The stream to write to.</param>
/// <param name="version">The ID3v2 version to use in writing the frame.</param>
protected void WriteFrameSize(Stream stream, ID3Versions version)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
switch (version)
{
case ID3Versions.V2_2:
stream.Write(EncodedInteger.ToBytes(this.Size, ID3V2_2FrameSizeFieldLength), 0, ID3V2_2FrameSizeFieldLength);
break;
case ID3Versions.V2_3:
stream.Write(EncodedInteger.ToBytes(this.Size, ID3V2_3FrameSizeFieldLength), 0, ID3V2_3FrameSizeFieldLength);
break;
case ID3Versions.V2_4:
stream.Write(SynchsafeInteger.Synchsafe(this.Size), 0, ID3V2_4FrameSizeFieldLength);
break;
default:
throw new UnsupportedVersionException(version);
}
}
public void TestSynchsafeIntToSynchsafeByte()
{
SynchsafeInteger testSSInt2 = new SynchsafeInteger(ssByte2);
int ssIntCalc = testSSInt2.SynchSafeInt;
Assert.AreEqual(ssInt2, ssIntCalc);
}
/// <summary>
/// Reads and returns the tag size from a stream.
/// </summary>
/// <param name="stream">The stream containing the tag.</param>
/// <returns>The tag size from a stream.</returns>
private static int ReadTagSize(Stream stream)
{
stream.Seek(TAG_SIZE_START, SeekOrigin.Begin);
byte[] tagSizeBytes = new byte[TAG_SIZE_LENGTH];
stream.Read(tagSizeBytes, 0, tagSizeBytes.Length);
int tagSize = SynchsafeInteger.UnSynchsafe(tagSizeBytes);
return(tagSize + TAG_HEADER_LENGTH);
}
public void SynchsafeIntToIntTest()
{
SynchsafeInteger testSSInt1 = new SynchsafeInteger(ssInt1);
SynchsafeInteger testSSInt2 = new SynchsafeInteger(ssInt2);
SynchsafeInteger testSSInt3 = new SynchsafeInteger(ssInt3);
Assert.AreEqual(expValue2, testSSInt2.ToInt());
Assert.AreEqual(expValue1, testSSInt1.ToInt());
Assert.AreEqual(expValue3, testSSInt3.ToInt());
}
public void SynchsafeByteToIntTest()
{
SynchsafeInteger testSSInt1 = new SynchsafeInteger(ssByte1);
SynchsafeInteger testSSInt2 = new SynchsafeInteger(ssByte2);
SynchsafeInteger testSSInt3 = new SynchsafeInteger(ssByte3);
SynchsafeInteger testSSInt4 = new SynchsafeInteger(ssByte4);
Assert.AreEqual(expValue1, testSSInt1.ToInt());
Assert.AreEqual(expValue2, testSSInt2.ToInt());
Assert.AreEqual(expValue3, testSSInt3.ToInt());
Assert.AreEqual(expValue4, testSSInt4.ToInt());
}
/// <summary>
/// Reads and returns a frame from a stream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="version">The ID3v2 version of the tag being parsed.</param>
/// <returns>The frame read from the stream.</returns>
public static ID3v2Frame ReadFrame(Stream stream, ID3Versions version)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
ID3v2Frame frame = null;
FrameParameters parameters = new FrameParameters(version);
byte[] header = new byte[parameters.HeaderLength];
char[] idChars = new char[parameters.IDLength];
byte[] sizeBytes = new byte[parameters.SizeLength];
byte[] flags = new byte[parameters.FlagsLength];
byte[] frameData;
string frameID;
int size;
stream.Read(header, 0, header.Length);
Array.Copy(header, 0, idChars, 0, idChars.Length);
Array.Copy(header, parameters.IDLength, sizeBytes, 0, sizeBytes.Length);
Array.Copy(header, parameters.IDLength + parameters.SizeLength, flags, 0, flags.Length);
if (idChars[0] != 0x0)
{
frameID = new String(idChars);
if (parameters.SizeIsSynchSafe)
{
size = SynchsafeInteger.UnSynchsafe(sizeBytes);
}
else
{
size = EncodedInteger.ToInt(sizeBytes);
}
frameData = new byte[size];
stream.Read(frameData, 0, frameData.Length);
FrameType frameType = FrameRegistry.GetFrameType(frameID, version);
frame = FrameRegistry.GetNewFrame(frameType);
frame.Initialize(flags, frameData, version);
}
else
{
frame = null;
}
return(frame);
}
/// <summary>
/// Writes the tag header to the specified stream.
/// </summary>
/// <param name="stream">The stream to be written to.</param>
/// <param name="version">The ID3v2 version of the tag to be written.</param>
private void WriteHeader(Stream stream, ID3Versions version)
{
if ((version & ID3Versions.V2) == ID3Versions.V2)
{
stream.Write(StringToBytes("ID3"), 0, 3);
WriteVersion(stream, version);
WriteFlags(stream, version);
stream.Write(
SynchsafeInteger.Synchsafe(this.GetFramesSize(version) + this.PaddingSize), 0, 4);
stream.Flush();
}
else
{
throw new UnsupportedVersionException(version);
}
}
