/// <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>
/// Create new AttachedPicture frame
/// </summary>
/// <param name="Flags">Flags of frame</param>
/// <param name="Description">Description of picture</param>
/// <param name="TextEncoding">TextEncoding use for texts</param>
/// <param name="MIMEType">MimeType of picture</param>
/// <param name="PictureType">Picture type</param>
/// <param name="Data">Data Contain picture</param>
public AttachedPictureFrame(FrameFlags Flags, string Description,
TextEncodings TextEncoding, string MIMEType, PictureTypes PictureType,
MemoryStream Data)
: base("APIC", Flags, Description, MIMEType, TextEncoding, Data)
{
_PictureType = PictureType;
}
public bool Read(byte[] buffer, ref int offset, ref int bytesTransferred)
{
while (bytesTransferred > 0)
{
switch (_receiveState)
{
case ExtensionFrameState.Flags:
Flags = (FrameFlags)buffer[offset];
_receiveState = ExtensionFrameState.ExtensionId;
++offset;
--bytesTransferred;
break;
case ExtensionFrameState.ExtensionId:
var extensionId = buffer[offset];
++offset;
--bytesTransferred;
_receiveState = ExtensionFrameState.Payload;
_receiveFrame = (ExtensionFrame)_extensionFactory(extensionId);
break;
case ExtensionFrameState.Payload:
var isCompleted = _receiveFrame.Read(buffer, ref offset, ref bytesTransferred);
if (isCompleted)
{
_frameReceived(_receiveFrame);
_receiveState = ExtensionFrameState.Flags;
}
return(isCompleted);
}
}
return(false);
}
internal static unsafe int ReadFrameInfo(byte *data, out FrameFlags frameFlags, out Rectangle rectangle, out int frameLength)
{
frameFlags = (FrameFlags)data[0];
rectangle = new Rectangle(*(int *)(data + 1), *(int *)(data + 5), *(int *)(data + 9), *(int *)(data + 13));
frameLength = *(int *)(data + 17);
return(FrameInfoLength);
}
public Equalisation(FrameFlags Flags, byte AdjustmentBits)
: base("EQUA", Flags)
{
this.AdjustmentLength = AdjustmentBits;
_Frequensies = new FramesCollection <FrequencyAdjustmentFrame>();
}
protected ExtensionFrame(byte extensionId)
{
_extensionId = extensionId;
_flags = FrameFlags.ExtensionFrame;
_receiveState = ExtensionFrameState.PayloadLength;
_sendCompleted = true;
}
public SynchronisedTempoFrame(FrameFlags Flags, TimeStamps TimeStamp)
: base("SYTC", Flags)
{
_TempoCodes = new FramesCollection <TempoCode>();
this.TimeStampFormat = TimeStamp;
}
internal void sendFrame0(ArraySegment <byte> compressed, FrameFlags flags, int targetPlayerId, bool reliable)
{
if ((flags & FrameFlags.Config) != 0)
{
reliable = true;
}
if ((flags & FrameFlags.KeyFrame) != 0)
{
reliable = true;
}
// sending reliably breaks timing
// consider sending multiple EndOfStream packets for reliability
if ((flags & FrameFlags.EndOfStream) != 0)
{
// reliable = true;
}
this.FramesSent++;
this.FramesSentBytes += compressed.Count;
this.voiceClient.transport.SendFrame(compressed, flags, evNumber, id, this.channelId, targetPlayerId, reliable, this);
if (this.DebugEchoMode)
{
this.eventTimestamps[evNumber] = Environment.TickCount;
}
evNumber++;
if (compressed.Count > 0 && (flags & FrameFlags.Config) == 0) // otherwise the frame is config or control (EOS)
{
lastTransmitTime = Environment.TickCount;
}
}
/// <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));
}
}
/// <summary>
/// Create new UserTextFrameClass
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">Frame Flagsr</param>
/// <param name="Data">TagStream to read information from</param>
/// <param name="Length">Maximum available length of data for current frame in TagStream</param>
public UserTextFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
TextEncoding = (TextEncodings)TStream.ReadByte(FS);
Length--;
if (!IsValidEnumValue(TextEncoding, ExceptionLevels.Error, FrameID))
{
return;
}
_Description = TStream.ReadText(Length, TextEncoding, ref Length, true);
if (!IsUrl) // is text frame
{
Text = TStream.ReadText(Length, TextEncoding);
}
else
{
Text = TStream.ReadText(Length, TextEncodings.Ascii);
}
// User URL frames use this class and use Text property as URL
// URL property must be in AScii format
// all URL frames start with W and text frames with T
}
/// <summary>
/// Create new OwnershipFrame
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">2 Bytes flags identifier</param>
/// <param name="Data">TagStream to read data from</param>
/// <param name="Length">Maximum available length for current frame is TagStream</param>
public OwnershipFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
TStream = new TagStreamUWP(FS);
TextEncoding = (TextEncodings)TStream.ReadByte(FS);
Length--;
if (!IsValidEnumValue(TextEncoding, ExceptionLevels.Error, FrameID))
{
return;
}
_Price = new Price(TStream, Length);
Length -= _Price.Length;
if (!_Price.IsValid)
{
ExceptionOccured(new ID3Exception("Price is not valid value. ownership frame will not read", FrameID, ExceptionLevels.Error));
return;
}
if (Length >= 8)
{
_DateOfPurch = new SDate(TStream);
Length -= 8;
}
else
{
ExceptionOccured(new ID3Exception("Date is not valid for this frame", FrameID, ExceptionLevels.Error));
return;
}
Seller = TStream.ReadText(Length, TextEncoding);
}
/// <summary>
/// New CommercialFrame
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Frame Flags</param>
/// <param name="Data">Data of frame</param>
/// <param name="Length">MaxLength of frame</param>
public CommercialFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
TStream = new TagStreamUWP(FS);
_TextEncoding = (TextEncodings)TStream.ReadByte(FS);
Length--;
if (!IsValidEnumValue(_TextEncoding, ExceptionLevels.Error, FrameID))
{
return;
}
_Price = new Price(TStream, Length);
Length -= _Price.Length;
_ValidUntil = new SDate(TStream);
Length -= 8;
_ContactUrl = TStream.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_RecievedAs = (RecievedAsEnum)Data.ReadByte();
Length--;
_SellerName = TStream.ReadText(Length, _TextEncoding, ref Length, true);
_Description = TStream.ReadText(Length, _TextEncoding, ref Length, true);
if (Length < 1) // Data finished
{
return;
}
_MIMEType = TStream.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_Data = TStream.ReadData(Length);
}
/// <summary>
/// New PopularimeterFrame
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">4 Characters tag identifier</param>
/// <param name="Data">TagStream contain frame data</param>
/// <param name="Length">Maximum available length for current frame in TagStream</param>
public PopularimeterFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
TStream = new TagStreamUWP(FS);
EMail = TStream.ReadText(Length, TextEncodings.Ascii, ref Length, true); // Read Email Address
_Rating = TStream.ReadByte(FS); // Read Rating
Length--;
if (Length > 8)
{
ExceptionOccured(new ID3Exception("Counter value for Popularimeter frame is more than 8 byte." +
" this is not supported by this program", FrameID, ExceptionLevels.Error));
return;
}
byte[] LBuf = new byte[8];
byte[] Buf = new byte[Length];
TStream.FS.Read(Buf, 0, Length);
Buf.CopyTo(LBuf, 8 - Buf.Length);
Array.Reverse(LBuf);
_Counter = BitConverter.ToInt64(LBuf, 0);
}
internal void sendFrame0(ArraySegment <byte> compressed, FrameFlags flags, int targetPlayerId, bool reliable)
{
if ((flags & FrameFlags.Config) != 0)
{
reliable = true;
}
if ((flags & FrameFlags.KeyFrame) != 0)
{
reliable = true;
}
// sending reliably breaks timing
// consider sending multiple EndOfStream packets for reliability
if ((flags & FrameFlags.EndOfStream) != 0)
{
// reliable = true;
}
this.FramesSent++;
this.FramesSentBytes += compressed.Count;
this.voiceClient.transport.SendFrame(compressed, flags, evNumber, id, this.channelId, targetPlayerId, reliable, this);
this.eventTimestamps[evNumber] = Environment.TickCount;
evNumber++;
resetNoTransmitCnt();
}
internal void onVoiceEvent(object content0, int channelId, int playerId, int localPlayerId)
{
object[] content = (object[])content0;
if ((byte)content[0] == (byte)0)
{
switch ((byte)content[1])
{
case (byte)EventSubcode.VoiceInfo:
this.onVoiceInfo(channelId, playerId, content[2]);
break;
case (byte)EventSubcode.VoiceRemove:
this.onVoiceRemove(channelId, playerId, content[2]);
break;
default:
logger.LogError("[PV] Unknown sevent subcode " + content[1]);
break;
}
}
else
{
byte voiceId = (byte)content[0];
byte evNumber = (byte)content[1];
byte[] receivedBytes = (byte[])content[2];
FrameFlags flags = 0;
if (content.Length > 3)
{
flags = (FrameFlags)content[3];
}
this.voiceClient.onFrame(channelId, playerId, voiceId, evNumber, receivedBytes, flags, playerId == localPlayerId);
}
}
public bool Read(byte[] buffer, ref int offset, ref int bytesTransferred)
{
while (bytesTransferred > 0)
{
switch (_receiveState)
{
case ExtensionFrameState.Flags:
Flags = (FrameFlags) buffer[offset];
_receiveState = ExtensionFrameState.ExtensionId;
++offset;
--bytesTransferred;
break;
case ExtensionFrameState.ExtensionId:
var extensionId = buffer[offset];
++offset;
--bytesTransferred;
_receiveState = ExtensionFrameState.Payload;
_receiveFrame = (ExtensionFrame) _extensionFactory(extensionId);
break;
case ExtensionFrameState.Payload:
var isCompleted = _receiveFrame.Read(buffer, ref offset, ref bytesTransferred);
if (isCompleted)
{
_frameReceived(_receiveFrame);
_receiveState = ExtensionFrameState.Flags;
}
return isCompleted;
}
}
return false;
}
protected ExtensionFrame(byte extensionId)
{
_extensionId = extensionId;
_flags = FrameFlags.ExtensionFrame;
_receiveState = ExtensionFrameState.PayloadLength;
_sendCompleted = true;
}
/// <summary>
/// Create new AttachedPictureFrame
/// </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">MaxLength of frame</param>
internal AttachedPictureFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length, Version version)
: base(FrameID, Flags)
{
_TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(_TextEncoding, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
if (version.Major == 2 && version.Minor == 2)
{
_MIMEType = Data.ReadText(3, TextEncodings.Ascii, ref Length, true);
}
else
{
_MIMEType = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true);
}
_PictureType = (PictureTypes)Data.ReadByte();
Length--;
_Description = Data.ReadText(Length, _TextEncoding, ref Length, true);
_Data = Data.ReadData(Length);
}
/// <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 OwnershipFrame
/// </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 OwnershipFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
{
return;
}
_Price = new Price(Data, Length);
Length -= _Price.Length;
if (!_Price.IsValid)
{
ErrorOccur("Price is not valid value. ownership frame will not read", true);
return;
}
if (Length >= 8)
{
_DateOfPurch = new SDate(Data);
Length -= 8;
}
else
{
ErrorOccur("Date is not valid for this frame", true);
return;
}
Seller = Data.ReadText(Length, TextEncoding);
}
public Frame(int length, FrameType type, FrameFlags flags, int streamId)
{
Length = length;
Type = type;
Flags = flags;
StreamId = streamId;
}
/// <summary>
/// New PrivateFrame
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Frame Flags</param>
/// <param name="Data">FileStream to read frame data from</param>
internal PrivateFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_Owner = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_Data = Data.ReadData(Length); // Read Data
}
/// <summary>
/// Create new AttachedPicture frame
/// </summary>
/// <param name="Flags">Flags of frame</param>
/// <param name="Description">Description of picture</param>
/// <param name="TextEncoding">TextEncoding use for texts</param>
/// <param name="MIMEType">MimeType of picture</param>
/// <param name="PictureType">Picture type</param>
/// <param name="Data">Data Contain picture</param>
public AttachedPictureFrame(FrameFlags Flags, string Description,
TextEncodings TextEncoding, string MIMEType, PictureTypes PictureType,
MemoryStream Data)
: base("APIC", Flags, Description, MIMEType, TextEncoding, Data)
{
_PictureType = PictureType;
}
/// <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="Length">Length to read from FileStream</param>
public RelativeVolumeFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
TStream = new TagStreamUWP(FS);
_Descriptors = new uint[12];
_IncDec = TStream.ReadByte(FS); // Read Increment Decrement Byte
_BitForVolumeDescription = TStream.ReadByte(FS); // Read Volume Description Length
Length -= 2;
if (_BitForVolumeDescription == 0)
{
ExceptionOccured(new ID3Exception("BitForVolumeDescription of Relative volume information frame can't be zero", ExceptionLevels.Error));
return;
}
if (_BitForVolumeDescription / 8 > 4 ||
_BitForVolumeDescription % 8 != 0)
{
ExceptionOccured(new ID3Exception("This program don't support " + _BitForVolumeDescription.ToString() +
" Bits of description for Relative Volume information", ExceptionLevels.Error));
return;
}
int DesLen = _BitForVolumeDescription / 8; // Length of each volume descriptor
int Counter = 0;
while (CanContinue(Length, DesLen, 2))
{
_Descriptors[Counter++] = TStream.ReadUInt(DesLen);
_Descriptors[Counter++] = TStream.ReadUInt(DesLen);
Length -= 2;
}
}
internal void receiveBytes(byte[] receivedBytes, FrameFlags flags, byte evNumber)
{
// receive-gap detection and compensation
if (evNumber != this.lastEvNumber) // skip check for 1st event
{
int missing = byteDiff(evNumber, this.lastEvNumber);
if (missing == 0)
{
this.lastEvNumber = evNumber;
}
else if (missing < 127)
{
this.voiceClient.logger.LogWarning(LogPrefix + " evNumer: " + evNumber + " playerVoice.lastEvNumber: " + this.lastEvNumber + " missing: " + missing + " r/b " + receivedBytes.Length);
this.voiceClient.FramesLost += missing;
this.lastEvNumber = evNumber;
// restoring missing frames
receiveNullFrames(missing);
}
else
{
// late (out of order) frames, just ignore them
// these frames already counted in FramesLost
this.voiceClient.logger.LogWarning(LogPrefix + " evNumer: " + evNumber + " playerVoice.lastEvNumber: " + this.lastEvNumber + " late: " + (255 - missing) + " r/b " + receivedBytes.Length);
}
}
this.receiveFrame(receivedBytes, flags);
}
/// <summary>
/// Create new UserTextFrameClass
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">Frame Flagsr</param>
/// <param name="Data">MemoryStream to read information from</param>
internal UserTextFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
_Description = Data.ReadText(Length, TextEncoding, ref Length, true);
if (!IsUrl) // is text frame
{
Text = Data.ReadText(Length, TextEncoding);
}
else
{
Text = Data.ReadText(Length, TextEncodings.Ascii);
}
// User URL frames use this class and use Text property as URL
// URL property must be in AScii format
// all URL frames start with W and text frames with T
}
public virtual void SendFrame(ArraySegment <byte> data, FrameFlags flags, byte evNumber, byte voiceId, int channelId, int targetPlayerId, bool reliable, LocalVoice localVoice)
{
object[] content = protocol.buildFrameMessage(voiceId, evNumber, data, flags);
var sendOpt = new SendOptions()
{
Reliability = reliable,
Channel = photonChannelForCodec(localVoice.Info.Codec),
Encrypt = localVoice.Encrypt
};
var opt = new RaiseEventOptions();
if (targetPlayerId == -1)
{
opt.TargetActors = new int[] { this.LocalPlayer.ActorNumber };
}
else if (targetPlayerId != 0)
{
opt.TargetActors = new int[] { targetPlayerId };
}
if (localVoice.DebugEchoMode)
{
opt.Receivers = ReceiverGroup.All;
}
opt.InterestGroup = localVoice.InterestGroup;
lock (sendLock)
{
this.OpRaiseEvent(VoiceEvent.Code, content, opt, sendOpt);
}
this.LoadBalancingPeer.SendOutgoingCommands();
}
/// <summary>
/// create new PositionSynchronised frame
/// </summary>
/// <param name="Flags">Flags of frame</param>
/// <param name="TimeStamp">TimeStamp to use for frame</param>
/// <param name="Position">Position of frame</param>
public PositionSynchronisedFrame(FrameFlags Flags, TimeStamps TimeStamp,
long Position)
: base("POSS", Flags)
{
this.TimeStamp = TimeStamp;
_Position = Position;
}
/// <summary>
/// Create new Equalisation frame
/// </summary>
/// <param name="FrameID">4 characters frame identifer of current Frame class</param>
/// <param name="Flags">Frame Flags</param>
/// <param name="Data">TagStream to read frame from</param>
/// <param name="Length">Maximum length to read frame</param>
public Equalisation(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
_Frequensies = new FrameCollection <FrequencyAdjustmentFrame>("Frequency Adjustment");
TStream = new BreadPlayer.Tags.TagStreamUWP(FS);
_AdjustmentBits = TStream.ReadByte(FS);
Length--;
if (_AdjustmentBits == 0)
{
ExceptionOccured(new ID3Exception("Adjustment bit of Equalisation is zero. this frame is invalid", FrameID, ExceptionLevels.Error));
return;
}
if (_AdjustmentBits % 8 != 0 || _AdjustmentBits > 32)
{
ExceptionOccured(new ID3Exception("AdjustmentBit of Equalisation Frame is out of supported range of this program", FrameID, ExceptionLevels.Error));
return;
}
int AdLen = _AdjustmentBits / 8;
int FreqBuf;
uint AdjBuf;
while (Length > 3)
{
FreqBuf = Convert.ToInt32(TStream.ReadUInt(2));
AdjBuf = TStream.ReadUInt(AdLen);
_Frequensies.Add(FrameID, new FrequencyAdjustmentFrame(FreqBuf, AdjBuf));
Length -= 2 + AdLen;
}
}
/// <summary>
/// Create new Equalisation Frame
/// </summary>
/// <param name="Flags">Frame Flags</param>
/// <param name="AdjustmentBits">AdjustmentBit of current </param>
public Equalisation(FrameFlags Flags, byte AdjustmentBits, Stream FS)
: base("EQUA", Flags, FS)
{
this.AdjustmentLength = AdjustmentBits;
_Frequensies = new FrameCollection <FrequencyAdjustmentFrame>("FrequencyAdjustment");
}
/// <summary>
/// Create new SynchronisedTempoFrame from TimeStamps
/// </summary>
/// <param name="Flags">FrameFlags</param>
/// <param name="TimeStamp">TimeStamps for current SynchronisedTempoFrame</param>
public SynchronisedTempoFrame(FrameFlags Flags, TimeStamps TimeStamp, Stream FS)
: base("SYTC", Flags, FS)
{
_TempoCodes = new FrameCollection <TempoCode>("Tempo Codes");
this.TimeStampFormat = TimeStamp;
}
/// <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>
public SynchronisedTempoFrame(string FrameID, FrameFlags Flags, int Length, Stream FS)
: base(FrameID, Flags, FS)
{
_TempoCodes = new FrameCollection <TempoCode>("Temnpo Codes");
TStream = new BreadPlayer.Tags.TagStreamUWP(FS);
_TimeStamp = (TimeStamps)TStream.ReadByte(FS);
if (IsValidEnumValue(_TimeStamp, ExceptionLevels.Error, FrameID))
{
return;
}
int Tempo;
uint Time;
while (Length > 4)
{
Tempo = TStream.ReadByte(FS);
Length--;
if (Tempo == 0xFF)
{
Tempo += TStream.ReadByte(FS);
Length--;
}
Time = TStream.ReadUInt(4);
Length -= 4;
_TempoCodes.Add(FrameID, new TempoCode(Tempo, Time));
}
}
/// <summary>
/// create new PositionSynchronised frame
/// </summary>
/// <param name="Flags">Flags of frame</param>
/// <param name="TimeStamp">TimeStamp to use for frame</param>
/// <param name="Position">Position of frame</param>
public PositionSynchronisedFrame(FrameFlags Flags, TimeStamps TimeStamp,
long Position)
: base("POSS", Flags)
{
this.TimeStamp = TimeStamp;
_Position = Position;
}
/// <summary>
/// New CommercialFrame
/// </summary>
/// <param name="FrameID">FrameID</param>
/// <param name="Flags">Frame Flags</param>
/// <param name="Data">Data of frame</param>
/// <param name="Length">MaxLength of frame</param>
internal CommercialFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(_TextEncoding, ValidatingErrorTypes.ID3Error))
{
return;
}
_Price = new Price(Data, Length);
Length -= _Price.Length;
_ValidUntil = new SDate(Data);
Length -= 8;
_ContactUrl = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_RecievedAs = (RecievedAsEnum)Data.ReadByte();
Length--;
_SellerName = Data.ReadText(Length, _TextEncoding, ref Length, true);
_Description = Data.ReadText(Length, _TextEncoding, ref Length, true);
if (Length < 1) // Data finished
{
return;
}
_MIMEType = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_Data = Data.ReadData(Length);
}
private void DecodeFlags(byte[] flags)
{
Flag = new FrameFlags();
Flag.TagAlterPreservation = (flags[0] & 0x80) == 0x80;
Flag.FileAlterPreservation = (flags[0] & 0x40) == 0x40;
Flag.ReadOnly = (flags[0] & 0x20) == 0x20;
Flag.Compression = (flags[1] & 0x80) == 0x80;
Flag.Encryption = (flags[1] & 0x40) == 0x40;
Flag.GroupingIdentify = (flags[1] & 0x20) == 0x20;
}
/// <summary>
/// New LinkedFrame from specific information
/// </summary>
/// <param name="Flags">Frame Flags</param>
/// <param name="FrameIdentifier">FrameIdentifier of frame that linked</param>
/// <param name="URL">URL address of Linked Frame</param>
/// <param name="AdditionalData">Additional data of Linked Frame</param>
public LinkFrame(FrameFlags Flags, string FrameIdentifier,
string URL, string AdditionalData)
: base("LINK", Flags)
{
this.URL = URL;
_AdditionalData = AdditionalData;
// Check if FrameIdentifier is valid
ValidatingFrameID(FrameIdentifier, ValidatingErrorTypes.Exception);
_FrameIdentifier = FrameIdentifier;
}
public FrameHeader(ByteVector data, byte version)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
this.flags = FrameFlags.None;
this.frame_size = 0;
if ((version < 2) || (version > 4))
{
throw new CorruptFileException("Unsupported tag version.");
}
if (data.Count < ((version != 2) ? 4 : 3))
{
throw new CorruptFileException("Data must contain at least a frame ID.");
}
switch (version)
{
case 2:
this.frame_id = ConvertId(data.Mid(0, 3), version, false);
if (data.Count >= 6)
{
this.frame_size = data.Mid(3, 3).ToUInt();
return;
}
return;
case 3:
this.frame_id = ConvertId(data.Mid(0, 4), version, false);
if (data.Count >= 10)
{
this.frame_size = data.Mid(4, 4).ToUInt();
this.flags = (FrameFlags) ((ushort) ((((data[8] << 7) & 0x7000) | ((data[9] >> 4) & 12)) | ((data[9] << 1) & 0x40)));
return;
}
return;
case 4:
this.frame_id = new ReadOnlyByteVector(data.Mid(0, 4));
if (data.Count >= 10)
{
this.frame_size = SynchData.ToUInt(data.Mid(4, 4));
this.flags = (FrameFlags) data.Mid(8, 2).ToUShort();
return;
}
return;
}
throw new CorruptFileException("Unsupported tag version.");
}
/// <summary>
/// Create new LinkFrame
/// </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 LinkFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_FrameIdentifier = Data.ReadText(4, TextEncodings.Ascii);
if (!ValidatingFrameID(_FrameIdentifier, ValidatingErrorTypes.ID3Error))
return;
Length -= 4;
// There is 3 byte in article that i think it's not true
// because frame identifier is 4 character
// use Text variable as URL
URL = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_AdditionalData = Data.ReadText(Length, TextEncodings.Ascii);
}
private string _ErrorMessage; // Contain Error Message if occur
/// <summary>
/// Create a new Frame class
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flag">Frame Falgs</param>
protected Frame(string FrameID, FrameFlags Flags)
{
// All FrameID letters must be capital
FrameID = FrameID.ToUpper();
if (!ValidatingFrameID(FrameID, ValidatingErrorTypes.Exception))
{
_MustDrop = true;
return;
}
_FrameFlags = Flags;
_FrameID = FrameID;
_MustDrop = false;
_IsLinked = false;
}
internal PositionSynchronisedFrame(string FrameID, FrameFlags Flags, FileStream Data, int Length)
: base(FrameID, Flags)
{
_TimeStamp = (TimeStamps)Data.ReadByte();
if (!IsValidEnumValue(_TimeStamp, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
Length--;
byte[] Long = new byte[8];
byte[] Buf = new byte[Length];
Data.Read(Buf, 0, Length);
Buf.CopyTo(Long, 8 - Buf.Length);
Array.Reverse(Long);
_Position = BitConverter.ToInt64(Long, 0);
}
/// <summary>
/// Create new AttachedPictureFrame
/// </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">MaxLength of frame</param>
internal AttachedPictureFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
_TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(_TextEncoding, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
_MIMEType = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true);
_PictureType = (PictureTypes)Data.ReadByte();
Length--;
_Description = Data.ReadText(Length, _TextEncoding, ref Length, true);
_Data = Data.ReadData(Length);
}
/// <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 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();
}
/*
*
* %0abc 0000 %0h00 kmnp
*
* a = Tag Alter Preservartion
* b = File Alter Preservation
* c = Read Only
* h = Grouping Identity
* k = Compression
* m = Encryption
* n = Unsynchronisation
* p = Data Length Indicator
*/
private void DecodeFlags(byte[] flags)
{
Flag = new FrameFlags();
var isTagAlterPreservation = (flags[0] & 0x40) == 0x40;
var isFileAlterPreservation = (flags[0] & 0x20) == 0x20;
var isReadOnly = (flags[0] & 0x10) == 0x10;
var isGroupingIdentity = (flags[1] & 0x40) == 0x40;
var isCompression = (flags[1] & 0x08) == 0x08;
var isEncryption = (flags[1] & 0x04) == 0x04;
var isUnsync = (flags[1] & 0x02) == 0x02;
var isDataLengthIndicator = (flags[1] & 0x01) == 0x01;
Flag.TagAlterPreservation = isTagAlterPreservation;
Flag.FileAlterPreservation = isFileAlterPreservation;
Flag.ReadOnly = isReadOnly;
Flag.GroupingIdentify = isGroupingIdentity;
Flag.Compression = isCompression;
Flag.Encryption = isEncryption;
Flag.Unsynchronisation = isUnsync;
Flag.DataLengthIndicator = isDataLengthIndicator;
}
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;
}
}
protected byte _IncDec; // Increment Decrement Byte
#endregion Fields
#region Constructors
/// <summary>
/// Create new RelativeVolumeInformation class
/// </summary>
/// <param name="Flags">Flags of Frame</param>
/// <param name="IncDec">Increment Decrement for each channel</param>
/// <param name="BitForVolumeDescription">Length of volume description</param>
public RelativeVolumeFrame(FrameFlags Flags, byte IncDec,
byte BitForVolumeDescription)
: base("RVAD", Flags)
{
_Descriptors = new uint[12];
_IncDec = IncDec;
this.BitsForVolumeDescription = BitForVolumeDescription;
}
/// <summary>
/// Create new PlayCounter
/// </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 PlayCounterFrame(string FrameID, FrameFlags Flags, FileStream Data, int Length)
: base(FrameID, Flags)
{
byte[] Long = new byte[8];
byte[] Buf = new byte[Length];
// Less than 4 Characters
Data.Read(Buf, 0, Length);
Buf.CopyTo(Long, 8 - Buf.Length);
Array.Reverse(Long);
_Counter = BitConverter.ToInt64(Long, 0);
}
/// <summary>
/// Create new PlayCounter
/// </summary>
/// <param name="Flags">Flags of frame</param>
public PlayCounterFrame(FrameFlags Flags)
: base("PCNT", Flags)
{
}
public TextWithLanguageFrame(string FrameID, FrameFlags Flags, string Text,
string Description, TextEncodings TextEncoding, string Lang)
: base(FrameID, Flags)
{
if (FrameID != "USLT" && FrameID != "COMM")
throw (new ArgumentException(FrameID + " is not valid Frame for TextWithLanguageFrame"));
Language = new Language(Lang);
this.Text = Text;
this.Description = "";
this.TextEncoding = TextEncoding;
}
/// <summary>
/// New PopulariMeter frame from specific information
/// </summary>
/// <param name="Flags">Frame Flags</param>
/// <param name="EMail">Email of user</param>
/// <param name="Rating">User Rated value</param>
/// <param name="Counter">How many times user listened to audio</param>
public PopularimeterFrame(FrameFlags Flags, string EMail,
byte Rating, long Counter)
: base("POPM", Flags)
{
base.Text = EMail;
_Rating = Rating;
_Counter = Counter;
}
/// <summary>
/// Create new TextFrame Class
/// </summary>
/// <param name="FrameID">4 Characters frame identifier</param>
/// <param name="Flags">Flag of frame</param>
/// <param name="Data">FileStream to read frame data from</param>
/// <param name="Length">Maximum length of frame</param>
internal TextFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
// If it was URL frame the TextEncoding is ascii and must not read
if (IsUrl)
TextEncoding = TextEncodings.Ascii;
else
{
TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
return;
}
Text = Data.ReadText(Length, _TextEncoding);
}
/// <summary>
/// Create new TextFrame with specific information
/// </summary>
/// <param name="Text">Text of TextFrame</param>
/// <param name="TextEncoding">TextEncoding of TextFrame</param>
/// <param name="FrameID">FrameID of TextFrame</param>
/// <param name="Flags">Flags of Frame</param>
public TextFrame(string FrameID, FrameFlags Flags, string Text, TextEncodings TextEncoding,
int Ver)
: base(FrameID, Flags)
{
if (FramesInfo.IsTextFrame(FrameID, Ver) != 1)
throw (new ArgumentException(FrameID + " is not valid TextFrame FrameID"));
this.Text = Text;
this.TextEncoding = TextEncoding;
}
protected TermOfUseFrame(string FrameID, FrameFlags Flags)
: base(FrameID, Flags)
{
}
/// <summary>
/// Create new TermOfUseFrame class
/// </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 TermOfUseFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
{
_MustDrop = true;
return;
}
_Language = new Language(Data);
Length -= 3;
Text = Data.ReadText(Length, TextEncoding);
}
public TermOfUseFrame(FrameFlags Flags, string Text,
TextEncodings TextEncoding, string Lang)
: base("USER", Flags)
{
this.Text = Text;
this.TextEncoding = TextEncoding;
Language = new Language(Lang);
}
/// <summary>
/// New PopularimeterFrame
/// </summary>
/// <param name="FrameID">4 Characters tag identifier</param>
/// <param name="Flags">Frame Flags</param>
/// <param name="Data">FileStream contain frame data</param>
internal PopularimeterFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
EMail = Data.ReadText(Length, TextEncodings.Ascii, ref Length, true); // Read Email Address
_Rating = Data.ReadByte(); // Read Rating
Length--;
if (Length > 8)
{
ErrorOccur("Counter value for Popularimeter frame is more than 8 byte." +
" this is not supported by this program", true);
return;
}
byte[] LBuf = new byte[8];
byte[] Buf = new byte[Length];
Data.Read(Buf, 0, Length);
Buf.CopyTo(LBuf, 8 - Buf.Length);
Array.Reverse(LBuf);
_Counter = BitConverter.ToInt64(LBuf, 0);
}
/// <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;
}
}
private string _Text; // Contain text
#endregion Fields
#region Constructors
protected TextOnlyFrame(string FrameID, FrameFlags Flags)
: base(FrameID, Flags)
{
}
/// <summary>
/// Create new Reverb frame and set all values to zero
/// </summary>
/// <param name="Flags">Frame Flags</param>
public ReverbFrame(FrameFlags Flags)
: base("RVRB", Flags)
{
}
/// <summary>
/// Create new OwnershipFrame
/// </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 OwnershipFrame(string FrameID, FrameFlags Flags, FileStreamEx Data, int Length)
: base(FrameID, Flags)
{
TextEncoding = (TextEncodings)Data.ReadByte();
Length--;
if (!IsValidEnumValue(TextEncoding, ValidatingErrorTypes.ID3Error))
return;
_Price = new Price(Data, Length);
Length -= _Price.Length;
if (!_Price.IsValid)
{
ErrorOccur("Price is not valid value. ownership frame will not read", true);
return;
}
if (Length >= 8)
{
_DateOfPurch = new SDate(Data);
Length -= 8;
}
else
{
ErrorOccur("Date is not valid for this frame", true);
return;
}
Seller = Data.ReadText(Length, TextEncoding);
}
