| public ReadUInt ( int Length ) : uint | ||
| Length | int | length of number in bytes |
| Résultat | uint | |
/// <summary>
/// Create new reveb frame
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Flags of frame</param>
/// <param name="Data">Data for frame to read from</param>
/// <param name="Length">Maximum length of frame</param>
internal ReverbFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
if (Length != 12)
{
//RaiseErrorEvent(new ID3Error(208, ID3Versions.ID3v2, _FrameID,
//"Reveb frame is not in correct length. it will drop", ErrorType.Error));
_MustDrop = true;
return;
}
_ReverbLeft = Convert.ToInt32(Data.ReadUInt(2));
_ReverbRight = Convert.ToInt32(Data.ReadUInt(2));
_ReverbBouncesLeft = Data.ReadByte();
_ReverbBouncesRight = Data.ReadByte();
_ReverbFeedbackLeftToLeft = Data.ReadByte();
_ReverbFeedbackLeftToRight = Data.ReadByte();
_ReverbFeedbackRightToRight = Data.ReadByte();
_ReverbFeedbackRightToLeft = Data.ReadByte();
_PremixLeftToRight = Data.ReadByte();
_PremixRightToLeft = Data.ReadByte();
}
protected uint _MilisecondBetweenRef; // 3 Bytes
#endregion Fields
#region Constructors
/// <summary>
/// Create new MpegLocationLookupTable
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Flags for this frame</param>
/// <param name="Data">FileStream to read data from</param>
internal MpegLocationLookupTable(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_FrameBetweenRef = Data.ReadUInt(2);
_ByteBetweenRef = Data.ReadUInt(3);
_ByteBetweenRef = Data.ReadUInt(3);
_BitsForByteDeviation = Data.ReadByte();
_BitsForMilisecondDeviation = Data.ReadByte();
Length -= 10;
int Sum = _BitsForByteDeviation + _BitsForMilisecondDeviation;
////BitForByteDev + BitForMilisecondDev must be multiple of four
//if (Sum % 4 != 0)
//{
// RaiseErrorEvent(new ID3Error(208, ID3Versions.ID3v2, _FrameID,
// "Error in MpegLocationLookupTable, it's not standard. it will drop", ErrorType.Error));
// _MustDrop = true;
// return;
//}
//if (Sum > 32 || Sum % 8 != 0)
//{
// RaiseErrorEvent(new ID3Error(208, ID3Versions.ID3v2, _FrameID,
// "this program can't process MpegLocation Table", ErrorType.Error));
// _MustDrop = true;
// return;
//}
uint Temp;
Sum /= 8;
while (Length >= Sum)
{
Temp = Data.ReadUInt(Sum);
Length -= Sum;
}
}
/// <summary>
/// New SynchronisedText
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Frame Flag</param>
/// <param name="Data">FileStream contain current frame data</param>
internal SynchronisedText(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Syllables = new FramesCollection<Syllable>();
TextEncoding = (TextEncodings)Data.ReadByte();
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
return;
Length--;
_Language = new Language(Data);
Length -= 3;
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
return;
Length--;
_ContentType = (ContentTypes)Data.ReadByte();
if (!IsValidEnumValue(_ContentType, ValidatingErrorTypes.Nothing))
_ContentType = ContentTypes.Other;
Length--;
// use Text variable for descriptor property
ContentDescriptor = Data.ReadText(Length, TextEncoding, ref Length, true);
string tempText;
uint tempTime;
while (Length > 5)
{
tempText = Data.ReadText(Length, TextEncoding, ref Length, true);
tempTime = Data.ReadUInt(4);
_Syllables.Add(new Syllable(tempTime, tempText));
Length -= 4;
}
}
/// <summary>
/// Create new RaltiveVolumeFrame
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">Contain Data for this frame</param>
/// <param name="Lenght">Length to read from FileStream</param>
internal RelativeVolumeFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Descriptors = new uint[12];
_IncDec = Data.ReadByte(); // Read Increment Decrement Byte
_BitForVolumeDescription = Data.ReadByte(); // Read Volume Description Length
Length -= 2;
if (_BitForVolumeDescription == 0)
{
ErrorOccur("BitForVolumeDescription of Relative volume information frame can't be zero", true);
return;
}
if (_BitForVolumeDescription / 8 > 4 ||
_BitForVolumeDescription % 8 != 0)
{
ErrorOccur("This program don't support " + _BitForVolumeDescription.ToString() +
" Bits of description for Relative Volume information", true);
return;
}
int DesLen = _BitForVolumeDescription / 8; // Length of each volume descriptor
int Counter = 0;
while (CanContinue(Length, DesLen, 2))
{
_Descriptors[Counter++] = Data.ReadUInt(DesLen);
_Descriptors[Counter++] = Data.ReadUInt(DesLen);
Length -= 2;
}
}
/// <summary>
/// Read all frames from specific FileStream
/// </summary>
/// <param name="Data">FileStream to read data from</param>
/// <param name="Length">Length of data to read from FileStream</param>
private void ReadFrames(FileStreamEx Data, int Length)
{
string FrameID;
int FrameLength;
FrameFlags Flags = new FrameFlags();
byte Buf;
// If ID3v2 is ID3v2.2 FrameID, FrameLength of Frames is 3 byte
// otherwise it's 4 character
int FrameIDLen = VersionInfo.Minor == 2 ? 3 : 4;
// Minimum frame size is 10 because frame header is 10 byte
while (Length > 10)
{
// check for padding( 00 bytes )
Buf = Data.ReadByte();
if (Buf == 0)
{
Length--;
continue;
}
// if readed byte is not zero. it must read as FrameID
Data.Seek(-1, SeekOrigin.Current);
// ---------- Read Frame Header -----------------------
FrameID = Data.ReadText(FrameIDLen, TextEncodings.Ascii);
if (FrameIDLen == 3)
FrameID = FramesInfo.Get4CharID(FrameID);
FrameLength = Convert.ToInt32(Data.ReadUInt(FrameIDLen));
if (FrameIDLen == 4)
Flags = (FrameFlags)Data.ReadUInt(2);
else
Flags = 0; // must set to default flag
long Position = Data.Position;
if (Length > 0x10000000)
throw (new FileLoadException("This file contain frame that have more than 256MB data"));
bool Added = false;
if (IsAddable(FrameID)) // Check if frame is not filter
Added = AddFrame(Data, FrameID, FrameLength, Flags);
if (!Added)
// if don't read this frame
// we must go forward to read next frame
Data.Position = Position + FrameLength;
Length -= FrameLength + 10;
}
}
/// <summary>
/// Create new AudioEncryptionFrame
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">Contain Data for this frame</param>
internal AudioEncryptionFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Owner = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_PreviewStart = Convert.ToInt32(Data.ReadUInt(2));
_PreviewLength = Convert.ToInt32(Data.ReadUInt(2));
Length -= 4;
_Data = Data.ReadData(Length);
}
/// <summary>
/// Create new RecomendedBufferSize
/// </summary>
/// <param name="FrameID">Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">Contain Data for this frame</param>
/// <param name="Lenght">Length to read from FileStream</param>
internal RecomendedBufferSizeFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_BufferSize = Data.ReadUInt(3);
_EmbededInfoFlag = Convert.ToBoolean(Data.ReadByte());
if (Length > 4)
_OffsetToNextTag = Data.ReadUInt(4);
}
internal EventTimingCodeFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Events = new FramesCollection<EventCode>();
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
Length--;
while (Length >= 5)
{
_Events.Add(new EventCode(Data.ReadByte(), Data.ReadUInt(4)));
Length -= 5;
}
}
/// <summary>
/// Create new Equalisation frame
/// </summary>
/// <param name="FrameID"></param>
/// <param name="Flags"></param>
/// <param name="Data"></param>
/// <param name="Length"></param>
internal Equalisation(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Frequensies = new FramesCollection<FrequencyAdjustmentFrame>();
_AdjustmentBits = Data.ReadByte();
Length--;
if (_AdjustmentBits == 0)
{
ErrorOccur("Adjustment bit of Equalisation is zero. this frame is invalid", true);
return;
}
if (_AdjustmentBits % 8 != 0 || _AdjustmentBits > 32)
{
ErrorOccur("AdjustmentBit of Equalisation Frame is out of supported range of this program", true);
return;
}
int AdLen = _AdjustmentBits / 8;
int FreqBuf;
uint AdjBuf;
while (Length > 3)
{
FreqBuf = Convert.ToInt32(Data.ReadUInt(2));
AdjBuf = Data.ReadUInt(AdLen);
_Frequensies.Add(new FrequencyAdjustmentFrame(FreqBuf, AdjBuf));
Length -= 2 + AdLen;
}
}
/// <summary>
/// Create new STempoCodes
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">Contain Data for this frame</param>
/// <param name="Length"></param>
internal SynchronisedTempoFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_TempoCodes = new FramesCollection<TempoCode>();
_TimeStamp = (TimeStamps)Data.ReadByte();
if (IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
int Tempo;
uint Time;
while (Length > 4)
{
Tempo = Data.ReadByte();
Length--;
if (Tempo == 0xFF)
{
Tempo += Data.ReadByte();
Length--;
}
Time = Data.ReadUInt(4);
Length -= 4;
_TempoCodes.Add(new TempoCode(Tempo, Time));
}
}
