public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
MimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 1)
{
byte flags = stream.Read1(ref bytesLeft);
_isMpegOrAac = ((flags & 0x01) == 0x00);
EquivalentText = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft > 0)
{
_audioData = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
else
{
EquivalentText = null;
_audioData = null;
}
}
else
{
MimeType = null;
EquivalentText = null;
_audioData = null;
}
}
else
{
TextEncoding = EncodingType.ISO88591;
MimeType = null;
EquivalentText = null;
_audioData = null;
}
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
Reset();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
OwnerIdentifier = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
MethodSymbol = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
EncryptionData = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
}
if (bytesLeft != 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 4)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
MimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
FileName = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft > 0)
{
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft > 0)
{
EncapsulatedObject = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
}
}
// Seek to end of frame
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
UserEmail = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
Rating = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
byte[] playCount = stream.Read(bytesLeft);
PlayCount = ByteUtils.ConvertToInt64(playCount);
}
else
{
PlayCount = 0;
}
}
else
{
Rating = 0;
PlayCount = 0;
}
}
else
{
UserEmail = null;
Rating = 0;
PlayCount = 0;
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
while (bytesLeft > 0)
{
stream.Read1(ref bytesLeft);
}
Value = true;
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
while (bytesLeft > 0)
{
stream.Read1(ref bytesLeft);
}
Value = true;
}
public static byte[] ReadUnsynchronized(Stream stream, int size)
{
using (MemoryStream byteList = new MemoryStream(size))
{
for (int i = 0; i < size; i++)
{
byte myByte = stream.Read1();
byteList.WriteByte(myByte);
if (myByte == 0xFF)
{
myByte = stream.Read1(); // skip 0x00
if (myByte != 0)
{
byteList.WriteByte(myByte);
i++;
}
}
}
return(byteList.ToArray());
}
}
public void ReadFrom(TagReadingInfo tagReadingInfo, Stream stream)
{
//Guard.ArgumentNotNull(stream, "stream");
int size = stream.ReadInt32();
// Test for a possible FrameID (0x41 = 'A')
// Most likely the extended header bit is set but
// there is no extended header. Set the stream back
// to its original position and return.
if (size >= 0x41000000)
{
string msg = string.Format("FrameID found when expected extended header at position {0}", stream.Position - 4);
Trace.WriteLine(msg);
stream.Seek(-4, SeekOrigin.Current);
_isCRCDataPresent = false;
_paddingSize = 0;
_totalFrameCRC = 0;
return;
}
byte flags1 = stream.Read1();
byte flags2 = stream.Read1();
_isCRCDataPresent = ((flags1 & 0x80) == 0x80);
_paddingSize = stream.ReadInt32();
if (_isCRCDataPresent)
{
_totalFrameCRC = (uint)stream.ReadInt32();
}
else
{
_totalFrameCRC = 0;
}
}
/// <summary>
/// Reads the ID3v1 tag from the specified stream.
/// </summary>
/// <param name="stream">The stream.</param>
public void Read(Stream stream)
{
if (stream.Length >= 128)
{
stream.Seek(-128, SeekOrigin.End);
if (GetString(stream, 3) == "TAG")
{
Title = GetString(stream, 30);
Artist = GetString(stream, 30);
Album = GetString(stream, 30);
Year = GetString(stream, 4);
// Comment
byte[] buf = new byte[30];
stream.Read(buf, 0, 30);
string comment = GetString(buf);
// ID3v1.1
if (buf[28] == 0 && buf[29] != 0)
{
TagVersion = ID3v1TagVersion.ID3v11;
Comment = GetTrimmedString(comment, 28);
TrackNumber = buf[29];
}
else
{
TagVersion = ID3v1TagVersion.ID3v10;
Comment = comment;
TrackNumber = null;
}
int genreIndex = stream.Read1();
if (genreIndex < 0 || genreIndex > 147)
{
genreIndex = 12; // "Other"
}
GenreIndex = genreIndex;
}
else
{
Reset();
}
}
else
{
Reset();
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
long playCount = 0;
while (bytesLeft > 0)
{
playCount <<= 8;
playCount += stream.Read1(ref bytesLeft);
}
Value = playCount;
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_languageItems.Clear();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 4)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
// This could be implemented many ways
// engfraspa etc
// eng 0x00 fra 0x00 spa 0x00 etc
// English
// English 0x00 French 0x00 Spanish 0x00
// TODO: Finish implementation
string languageCode = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (languageCode.Length != 3)
{
if (languageCode.ToLower() == "english" || languageCode.ToLower() == "en")
{
Items.AddNew().LanguageCode = "eng";
}
else
{
foreach (KeyValuePair <string, string> kvp in LanguageHelper.Languages)
{
if (kvp.Value.ToLower() == languageCode.ToLower())
{
Items.AddNew().LanguageCode = kvp.Key;
break;
}
}
}
}
else
{
Items.AddNew().LanguageCode = languageCode;
}
}
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
long playCount = 0;
while (bytesLeft > 0)
{
playCount <<= 8;
playCount += stream.Read1(ref bytesLeft);
}
Value = playCount;
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
// Some taggers write 0 byte sized frames (which is explicitly forbidden by the spec)
if (_frameHeader.FrameSizeExcludingAdditions >= 1)
{
TextEncoding = (EncodingType)stream.Read1();
Value = ID3v2Utils.ReadString(_textEncoding, stream, _frameHeader.FrameSizeExcludingAdditions - 1);
}
else
{
//String msg = String.Format("Under-sized ({0} bytes) text frame at position {1}", m_FrameHeader.FrameSizeExcludingAdditions, stream.Position);
//Trace.WriteLine(msg);
TextEncoding = EncodingType.ISO88591;
Value = "";
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
if (_frameHeader.FrameSizeExcludingAdditions > 0)
{
TextEncoding = (EncodingType)stream.Read1();
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions - 1;
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
Value = ID3v2Utils.ReadString(TextEncoding, stream, bytesLeft);
}
else
{
/*String msg = String.Format("0 length frame '{0}' at position {1}", "TXXX", stream.Position);
* Trace.WriteLine(msg);*/
Description = string.Empty;
Value = string.Empty;
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
if (_frameHeader.FrameSizeExcludingAdditions >= 4)
{
TextEncoding = (EncodingType)stream.Read1();
LanguageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
int tmpBytesLeft = _frameHeader.FrameSizeExcludingAdditions - 1 /*encoding*/ - 3 /*language code*/;
ContentDescriptor = ID3v2Utils.ReadString(TextEncoding, stream, ref tmpBytesLeft);
Text = ID3v2Utils.ReadString(_textEncoding, stream, tmpBytesLeft);
}
else
{
string msg = string.Format("Under-sized ({0} bytes) unsynchronized text frame at position {1}", _frameHeader.FrameSizeExcludingAdditions, stream.Position);
Trace.WriteLine(msg);
LanguageCode = "eng";
ContentDescriptor = "";
Text = "";
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 1)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (bytesLeft >= 3)
{
LanguageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
bytesLeft -= 3;
if (bytesLeft > 0)
{
Value = ID3v2Utils.ReadString(TextEncoding, stream, bytesLeft);
bytesLeft = 0;
}
}
else
{
LanguageCode = "eng";
}
}
else
{
TextEncoding = EncodingType.ISO88591;
LanguageCode = "eng";
}
// Seek past any unread bytes
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
_involvedPersons.Clear();
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
while (bytesLeft > 0)
{
string involvement = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
string name = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (!string.IsNullOrEmpty(involvement) || !string.IsNullOrEmpty(name))
{
IInvolvedPerson involvedPerson = _involvedPersons.AddNew();
involvedPerson.Involvement = involvement;
involvedPerson.Name = name;
}
}
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
Reset();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 1)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
string priceString = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (!string.IsNullOrEmpty(priceString))
{
foreach (string priceItem in priceString.Split('/'))
{
if (priceItem.Length > 3)
{
decimal price;
string pricePart = priceItem.Substring(3, priceItem.Length - 3);
if (decimal.TryParse(pricePart, System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out price))
{
IPriceInformation priceInfo = new PriceInformation();
priceInfo.CurrencyCode = priceItem.Substring(0, 3);
priceInfo.Price = price;
_priceList.Add(priceInfo);
}
}
}
}
if (bytesLeft > 0)
{
string validUntil = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 8);
bytesLeft -= 8;
if (validUntil.Length == 8)
{
validUntil = string.Format("{0}-{1}-{2}", validUntil.Substring(0, 4),
validUntil.Substring(4, 2), validUntil.Substring(6, 2));
DateTime.TryParse(validUntil, out _validUntil);
}
if (bytesLeft > 0)
{
ContactUrl = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
ReceivedAs = (ReceivedAs)stream.Read1(ref bytesLeft);
NameOfSeller = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
SellerLogoMimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
SellerLogo = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
}
}
}
if (bytesLeft != 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
private int getSamples(Stream stream)
{
int SampleNumber = 0;
int i;
int nscan = 0;
version = MAX_VERSION + 1;
while (version > MAX_VERSION)
{
int myByte = stream.Read1();
if (MAGIC[nscan] != '\0' && myByte == MAGIC[nscan])
{
nscan++;
}
else if (MAGIC[nscan] == '\0' && myByte <= MAX_VERSION)
{
version = myByte;
}
else
{
if (myByte == MAGIC[0])
{
nscan = 1;
}
else
{
nscan = 0;
}
version = MAX_VERSION + 1;
}
}
// check version number
if (version > MAX_SUPPORTED_VERSION)
return 0;
UINT_GET(TYPESIZE, stream);
int blocksize;
int nchan = (int)UINT_GET(CHANSIZE, stream);
if (version > 0)
{
blocksize = (int)UINT_GET((int)(Math.Log(DEFAULT_BLOCK_SIZE) / M_LN2), stream);
UINT_GET(LPCQSIZE, stream);
UINT_GET(0, stream);
int nskip = (int)UINT_GET(NSKIPSIZE, stream);
for (i = 0; i < nskip; i++)
{
uvar_get(XBYTESIZE, stream);
}
}
else
{
blocksize = DEFAULT_BLOCK_SIZE;
}
// get commands from file and execute them
int chan = 0;
int cmd = uvar_get(FNSIZE, stream);
while (cmd != FN_QUIT)
{
switch (cmd)
{
case FN_ZERO:
case FN_DIFF0:
case FN_DIFF1:
case FN_DIFF2:
case FN_DIFF3:
case FN_QLPC:
int resn = 0;
if (cmd != FN_ZERO)
{
resn = uvar_get(ENERGYSIZE, stream);
// this is a hack as version 0 differed in definition of var_get
if (version == 0) resn--;
}
switch (cmd)
{
case FN_ZERO:
break;
case FN_DIFF0:
case FN_DIFF1:
case FN_DIFF2:
case FN_DIFF3:
for (i = 0; i < blocksize; i++)
{
int nbin = resn + 1;
if (nbitget == 0)
{
if (nbyteget < 4)
{
int bytes = stream.Read(getbuf, 0, BUFSIZE);
getbufOffset = 0;
nbyteget += bytes;
}
gbuffer = (((uint)getbuf[getbufOffset]) << 24) | (((uint)getbuf[getbufOffset + 1]) << 16) |
(((uint)getbuf[getbufOffset + 2]) << 8) | (getbuf[getbufOffset + 3]);
getbufOffset += 4;
nbyteget -= 4;
nbitget = 32;
}
while ((gbuffer & (1L << --nbitget)) == 0)
{
if (nbitget == 0)
{
if (nbyteget < 4)
{
int bytes = stream.Read(getbuf, 0, BUFSIZE);
getbufOffset = 0;
nbyteget += bytes;
}
gbuffer = (((uint)getbuf[getbufOffset]) << 24) | (((uint)getbuf[getbufOffset + 1]) << 16) |
(((uint)getbuf[getbufOffset + 2]) << 8) | (getbuf[getbufOffset + 3]);
getbufOffset += 4;
nbyteget -= 4;
nbitget = 32;
}
}
while (nbin != 0)
{
if (nbitget >= nbin)
{
nbitget -= nbin;
nbin = 0;
}
else
{
if (nbyteget < 4)
{
int bytes = stream.Read(getbuf, 0, BUFSIZE);
getbufOffset = 0;
nbyteget += bytes;
}
gbuffer = (((uint)getbuf[getbufOffset]) << 24) | (((uint)getbuf[getbufOffset + 1]) << 16) |
(((uint)getbuf[getbufOffset + 2]) << 8) | (getbuf[getbufOffset + 3]);
getbufOffset += 4;
nbyteget -= 4;
nbin -= nbitget;
nbitget = 32;
}
}
}
break;
case FN_QLPC:
int nlpc = uvar_get(LPCQSIZE, stream);
for (i = 0; i < nlpc; i++)
var_get(LPCQUANT, stream);
break;
}
if (chan == nchan - 1)
{
SampleNumber += blocksize;
}
chan = (chan + 1) % nchan;
break;
case FN_BLOCKSIZE:
blocksize = (int)UINT_GET((int)(Math.Log(blocksize) / M_LN2), stream);
break;
case FN_BITSHIFT:
uvar_get(BITSHIFTSIZE, stream);
break;
case FN_VERBATIM:
int cklen = uvar_get(VERBATIM_CKSIZE_SIZE, stream);
while (cklen-- != 0)
{
uvar_get(VERBATIM_BYTE_SIZE, stream);
}
break;
default:
return 0;
}
cmd = uvar_get(FNSIZE, stream);
}
return SampleNumber;
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
if (_frameHeader.FrameSizeExcludingAdditions > 0)
{
TextEncoding = (EncodingType)stream.Read1();
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions - 1;
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
Value = ID3v2Utils.ReadString(TextEncoding, stream, bytesLeft);
}
else
{
/*String msg = String.Format("0 length frame '{0}' at position {1}", "TXXX", stream.Position);
Trace.WriteLine(msg);*/
Description = string.Empty;
Value = string.Empty;
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
// RVAD/RVA2
/*Double original = -65534;
Double newVal = Math.Log10(1 + original/65535.0)*20.0*512.0;
Double original2 = Math.Pow(10, newVal/(20.0*512.0));
original2 = original2 - 1;
original2 *= 65535.0;*/
/*Double original = 10000;
Double newVal = Math.Log10(1 + original / 65535.0);
Double original2 = Math.Pow(10, newVal);
original2 = original2 - 1;
original2 *= 65535.0;*/
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
// todo: there needs to be some kind of a test to see if this is RVAD/RVA2 format, too
// much varying implementation in 2.3 and 2.4
bool isRVA2 = (_frameHeader.TagVersion == ID3v2TagVersion.ID3v24);
if (isRVA2)
{
// sometimes "identification" is completely ommitted... grr
Identification = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
while (bytesLeft >= 3)
{
// TODO: Implementation not complete
byte channelType = stream.Read1(ref bytesLeft);
//if (channelType == 16) break; // Invalid, probably stored as an ID3v2.3 RVAD frame
// TODO: some kind of switch.. maybe a new internal enum
short volumeAdjustment = stream.ReadInt16(ref bytesLeft);
if (bytesLeft > 0)
{
// sometimes represented as BITS representing peak.. seriously.
byte bytesRepresentingPeak = stream.Read1(ref bytesLeft);
if (bytesRepresentingPeak == 0) break;
if (bytesLeft >= bytesRepresentingPeak)
{
// TODO: Finish implementation
byte[] peakVolume = stream.Read(bytesRepresentingPeak);
bytesLeft -= peakVolume.Length;
}
else
{
break;
}
}
}
if (bytesLeft > 0)
{
//Trace.WriteLine("Invalid RVA2 frame");
//stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
// Try to read it like an ID3v2.3 RVAD frame
stream.Seek(bytesLeft - _frameHeader.FrameSizeExcludingAdditions, SeekOrigin.Current);
bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
isRVA2 = false;
}
else
{
// TODO
//MessageBox.Show("valid RVA2 frame, omg!");
}
}
// ID3v2.2, ID3v2.3, or mal-formed ID3v2.4
if (isRVA2 == false)
{
byte incrementDecrement = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
byte bitsUsedForVolumeDescription = stream.Read1(ref bytesLeft);
int bytesUsedForVolumeDescription = bitsUsedForVolumeDescription / 8;
// TODO: (may be useful for testing which implementation)
// if bits used for volume description is > 64, don't bother
// Relative volume change, right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 0) ? 1 : -1);
}
// Relative volume change, left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 1) ? 1 : -1);
}
// Peak volume right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 2) ? 1 : -1);
}
// Relative volume change, left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 3) ? 1 : -1);
}
// Peak volume right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 4) ? 1 : -1);
}
// Peak volume center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 5) ? 1 : -1);
}
// Peak volume bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferPeak = ByteUtils.ConvertToInt64(byteArray);
}
}
}
// Skip past the rest of the frame
if (bytesLeft > 0)
{
Trace.WriteLine("Invalid RVA2/RVAD/RVA frame");
stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
}
}
}
public static string ReadString(EncodingType textEncoding, Stream stream, ref int bytesLeft)
{
if (bytesLeft <= 0)
{
//String msg = String.Format("ReadString (unknown length) called with {0} bytes left at position {1}", bytesLeft, stream.Position);
//Trace.WriteLine(msg);
return(string.Empty);
}
string returnValue;
List <byte> byteList = new List <byte>();
if (textEncoding == EncodingType.ISO88591)
{
byte readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return("");
}
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
if (readByte != 0)
{
byteList.Add(readByte);
}
return(ByteUtils.ISO88591GetString(byteList.ToArray()));
}
}
returnValue = ByteUtils.ISO88591GetString(byteList.ToArray());
}
else if (textEncoding == EncodingType.Unicode)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return("");
}
byte2 = stream.Read1();
byteList.Add(byte2);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
break;
//return "";
}
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, decode as the appropriate Unicode type.
// If no BOM is present use Little Endian Unicode.
if (byteArray[0] == 0xFF && byteArray[1] == 0xFE)
{
returnValue = Encoding.Unicode.GetString(byteArray, 2, byteArray.Length - 2);
}
else if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
}
else
{
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
}
else
{
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF16BE)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return("");
}
byte2 = stream.Read1();
byteList.Add(byte2);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
break;
//return "";
}
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, remove before decoding.
if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
}
else
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
}
else
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF8)
{
byte readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return("");
}
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return("");
}
}
returnValue = Encoding.UTF8.GetString(byteList.ToArray());
}
else
{
// Most likely bad data
string msg = string.Format("Text Encoding '{0}' unknown at position {1}", textEncoding, stream.Position);
Trace.WriteLine(msg);
return("");
}
returnValue = returnValue.TrimEnd('\0');
return(returnValue);
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
// Sometimes a frame size of "0" comes through (which is explicitly forbidden in spec)
if (_frameHeader.FrameSizeExcludingAdditions >= 1)
{
TextEncoding = (EncodingType)stream.Read1();
// TODO: A common mis-implementation is to exclude the language code and description
// Haven't decided how to handle this yet. Maybe if a lookup to the language table fails,
// the rest of the frame should be treated as suspicious.
if (_frameHeader.FrameSizeExcludingAdditions >= 4)
{
string languageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions - 1 - 3;
string description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
bool invalidFrame = false;
if (LanguageHelper.Languages.ContainsKey(languageCode.ToLower()) == false && languageCode.ToLower() != "xxx")
{
// most likely, it's en\0, or some other funk
if (languageCode.StartsWith("en"))
{
languageCode = "";
}
invalidFrame = true;
if (bytesLeft == 0)
{
Description = "";
}
else
{
Description = languageCode + description;
}
LanguageCode = "eng";
}
else
{
LanguageCode = languageCode;
Description = description;
}
if (bytesLeft > 0)
{
Value = ID3v2Utils.ReadString(TextEncoding, stream, bytesLeft);
}
else
{
if (invalidFrame)
{
if (languageCode.Contains("\0"))
{
// forget it, too messed up.
Value = "";
}
else
{
Value = languageCode + description;
}
}
else
{
Value = "";
}
}
}
else
{
string msg = string.Format("Under-sized ({0} bytes) COMM frame at position {1}", _frameHeader.FrameSizeExcludingAdditions, stream.Position);
Trace.WriteLine(msg);
LanguageCode = "eng";
Value = "";
}
}
else
{
string msg = string.Format("Under-sized ({0} bytes) COMM frame at position {1}", _frameHeader.FrameSizeExcludingAdditions, stream.Position);
Trace.WriteLine(msg);
LanguageCode = "eng";
Value = "";
}
}
public void ReadFrom(TagReadingInfo tagReadingInfo, Stream stream)
{
//Guard.ArgumentNotNull(stream, "stream");
int size = stream.ReadInt32();
// Test for a possible FrameID (0x41 = 'A')
// Most likely the extended header bit is set but
// there is no extended header. Set the stream back
// to its original position and return.
if (size >= 0x41000000)
{
string msg = string.Format("FrameID found when expected extended header at position {0}", stream.Position - 4);
Trace.WriteLine(msg);
stream.Seek(-4, SeekOrigin.Current);
_isCRCDataPresent = false;
_paddingSize = 0;
_totalFrameCRC = 0;
return;
}
byte flags1 = stream.Read1();
byte flags2 = stream.Read1();
_isCRCDataPresent = ((flags1 & 0x80) == 0x80);
_paddingSize = stream.ReadInt32();
if (_isCRCDataPresent)
{
_totalFrameCRC = (uint)stream.ReadInt32();
}
else
{
_totalFrameCRC = 0;
}
}
private int getSamples(Stream stream)
{
int SampleNumber = 0;
int i;
int nscan = 0;
version = MAX_VERSION + 1;
while (version > MAX_VERSION)
{
int myByte = stream.Read1();
if (MAGIC[nscan] != '\0' && myByte == MAGIC[nscan])
{
nscan++;
}
else if (MAGIC[nscan] == '\0' && myByte <= MAX_VERSION)
{
version = myByte;
}
else
{
if (myByte == MAGIC[0])
{
nscan = 1;
}
else
{
nscan = 0;
}
version = MAX_VERSION + 1;
}
}
// check version number
if (version > MAX_SUPPORTED_VERSION)
{
return(0);
}
UINT_GET(TYPESIZE, stream);
int blocksize;
int nchan = (int)UINT_GET(CHANSIZE, stream);
if (version > 0)
{
blocksize = (int)UINT_GET((int)(Math.Log(DEFAULT_BLOCK_SIZE) / M_LN2), stream);
UINT_GET(LPCQSIZE, stream);
UINT_GET(0, stream);
int nskip = (int)UINT_GET(NSKIPSIZE, stream);
for (i = 0; i < nskip; i++)
{
uvar_get(XBYTESIZE, stream);
}
}
else
{
blocksize = DEFAULT_BLOCK_SIZE;
}
// get commands from file and execute them
int chan = 0;
int cmd = uvar_get(FNSIZE, stream);
while (cmd != FN_QUIT)
{
switch (cmd)
{
case FN_ZERO:
case FN_DIFF0:
case FN_DIFF1:
case FN_DIFF2:
case FN_DIFF3:
case FN_QLPC:
int resn = 0;
if (cmd != FN_ZERO)
{
resn = uvar_get(ENERGYSIZE, stream);
// this is a hack as version 0 differed in definition of var_get
if (version == 0)
{
resn--;
}
}
switch (cmd)
{
case FN_ZERO:
break;
case FN_DIFF0:
case FN_DIFF1:
case FN_DIFF2:
case FN_DIFF3:
for (i = 0; i < blocksize; i++)
{
int nbin = resn + 1;
if (nbitget == 0)
{
if (nbyteget < 4)
{
int bytes = stream.Read(getbuf, 0, BUFSIZE);
getbufOffset = 0;
nbyteget += bytes;
}
gbuffer = (((uint)getbuf[getbufOffset]) << 24) | (((uint)getbuf[getbufOffset + 1]) << 16) |
(((uint)getbuf[getbufOffset + 2]) << 8) | (getbuf[getbufOffset + 3]);
getbufOffset += 4;
nbyteget -= 4;
nbitget = 32;
}
while ((gbuffer & (1L << --nbitget)) == 0)
{
if (nbitget == 0)
{
if (nbyteget < 4)
{
int bytes = stream.Read(getbuf, 0, BUFSIZE);
getbufOffset = 0;
nbyteget += bytes;
}
gbuffer = (((uint)getbuf[getbufOffset]) << 24) | (((uint)getbuf[getbufOffset + 1]) << 16) |
(((uint)getbuf[getbufOffset + 2]) << 8) | (getbuf[getbufOffset + 3]);
getbufOffset += 4;
nbyteget -= 4;
nbitget = 32;
}
}
while (nbin != 0)
{
if (nbitget >= nbin)
{
nbitget -= nbin;
nbin = 0;
}
else
{
if (nbyteget < 4)
{
int bytes = stream.Read(getbuf, 0, BUFSIZE);
getbufOffset = 0;
nbyteget += bytes;
}
gbuffer = (((uint)getbuf[getbufOffset]) << 24) | (((uint)getbuf[getbufOffset + 1]) << 16) |
(((uint)getbuf[getbufOffset + 2]) << 8) | (getbuf[getbufOffset + 3]);
getbufOffset += 4;
nbyteget -= 4;
nbin -= nbitget;
nbitget = 32;
}
}
}
break;
case FN_QLPC:
int nlpc = uvar_get(LPCQSIZE, stream);
for (i = 0; i < nlpc; i++)
{
var_get(LPCQUANT, stream);
}
break;
}
if (chan == nchan - 1)
{
SampleNumber += blocksize;
}
chan = (chan + 1) % nchan;
break;
case FN_BLOCKSIZE:
blocksize = (int)UINT_GET((int)(Math.Log(blocksize) / M_LN2), stream);
break;
case FN_BITSHIFT:
uvar_get(BITSHIFTSIZE, stream);
break;
case FN_VERBATIM:
int cklen = uvar_get(VERBATIM_CKSIZE_SIZE, stream);
while (cklen-- != 0)
{
uvar_get(VERBATIM_BYTE_SIZE, stream);
}
break;
default:
return(0);
}
cmd = uvar_get(FNSIZE, stream);
}
return(SampleNumber);
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
if (_frameHeader.FrameSizeExcludingAdditions >= 4)
{
TextEncoding = (EncodingType)stream.Read1();
LanguageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
int tmpBytesLeft = _frameHeader.FrameSizeExcludingAdditions - 1 /*encoding*/- 3 /*language code*/;
ContentDescriptor = ID3v2Utils.ReadString(TextEncoding, stream, ref tmpBytesLeft);
Text = ID3v2Utils.ReadString(_textEncoding, stream, tmpBytesLeft);
}
else
{
string msg = string.Format("Under-sized ({0} bytes) unsynchronized text frame at position {1}", _frameHeader.FrameSizeExcludingAdditions, stream.Position);
Trace.WriteLine(msg);
LanguageCode = "eng";
ContentDescriptor = "";
Text = "";
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
Reset();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
OwnerIdentifier = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
MethodSymbol = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
EncryptionData = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
}
if (bytesLeft != 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
Items.Clear();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 1)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (bytesLeft >= 3)
{
LanguageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
bytesLeft -= 3;
if (bytesLeft >= 2)
{
TimestampFormat = (TimestampFormat)stream.Read1(ref bytesLeft);
ContentType = (TextContentType)stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
ContentDescriptor = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
while (bytesLeft > 0)
{
string lyrics = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft >= 4)
{
SynchronizedTextItem textItem = new SynchronizedTextItem();
textItem.Text = lyrics;
textItem.Timestamp = stream.ReadInt32();
bytesLeft -= 4;
Items.Add(textItem);
}
}
}
else
{
// Incomplete frame
ContentDescriptor = "";
}
}
else
{
// Incomplete frame
TimestampFormat = TimestampFormat.Milliseconds;
ContentType = TextContentType.Other;
ContentDescriptor = "";
}
}
else
{
// Incomplete frame
LanguageCode = "eng";
TimestampFormat = TimestampFormat.Milliseconds;
ContentType = TextContentType.Other;
ContentDescriptor = "";
}
}
else
{
// Incomplete frame
TextEncoding = EncodingType.ISO88591;
LanguageCode = "eng";
TimestampFormat = TimestampFormat.Milliseconds;
ContentType = TextContentType.Other;
ContentDescriptor = "";
}
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public void Read(TagReadingInfo tagReadingInfo, ref Stream stream)
{
// TODO: Some tags have the length INCLUDE the extra ten bytes of the tag header.
// Handle this (don't corrupt MP3 on rewrite)
m_TagVersion = tagReadingInfo.TagVersion;
bool usesUnsynchronization = ((tagReadingInfo.TagVersionOptions & TagVersionOptions.Unsynchronized) == TagVersionOptions.Unsynchronized);
if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v23)
{
if (!usesUnsynchronization)
m_FrameSize = stream.ReadInt32();
else
m_FrameSize = ID3v2Utils.ReadInt32Unsynchronized(stream);
m_FrameSizeExcludingAdditions = m_FrameSize;
byte byte0 = stream.Read1();
byte byte1 = stream.Read1();
// First byte
IsTagAlterPreservation = ((byte0 & 0x80) == 0x80);
IsFileAlterPreservation = ((byte0 & 0x40) == 0x40);
IsReadOnly = ((byte0 & 0x20) == 0x20);
// Second byte
IsCompressed = ((byte1 & 0x80) == 0x80);
bool tmpIsEncrypted = ((byte1 & 0x40) == 0x40);
bool tmpIsGroupingIdentity = ((byte1 & 0x20) == 0x20);
// Additional bytes
// Compression
if (IsCompressed)
{
DecompressedSize = stream.ReadInt32();
m_FrameSizeExcludingAdditions -= 4;
}
else
{
DecompressedSize = 0;
}
// Encryption
if (tmpIsEncrypted)
{
EncryptionMethod = stream.Read1();
m_FrameSizeExcludingAdditions -= 1;
}
else
{
EncryptionMethod = null;
}
// Grouping Identity
if (tmpIsGroupingIdentity)
{
GroupingIdentity = stream.Read1();
m_FrameSizeExcludingAdditions -= 1;
}
else
{
GroupingIdentity = null;
}
if (usesUnsynchronization)
{
stream = ID3v2Utils.ReadUnsynchronizedStream(stream, m_FrameSize);
}
}
else if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v22)
{
if (!usesUnsynchronization)
m_FrameSize = stream.ReadInt24();
else
m_FrameSize = ID3v2Utils.ReadInt24Unsynchronized(stream);
if ((tagReadingInfo.TagVersionOptions & TagVersionOptions.AddOneByteToSize) == TagVersionOptions.AddOneByteToSize)
{
m_FrameSize++;
}
m_FrameSizeExcludingAdditions = m_FrameSize;
// These fields are not supported in ID3v2.2
IsTagAlterPreservation = false;
IsFileAlterPreservation = false;
IsReadOnly = false;
IsCompressed = false;
DecompressedSize = 0;
EncryptionMethod = null;
GroupingIdentity = null;
if (usesUnsynchronization)
{
stream = ID3v2Utils.ReadUnsynchronizedStream(stream, m_FrameSize);
}
}
else if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v24)
{
if ((tagReadingInfo.TagVersionOptions & TagVersionOptions.UseNonSyncSafeFrameSizeID3v24) == TagVersionOptions.UseNonSyncSafeFrameSizeID3v24)
m_FrameSize = stream.ReadInt32();
else
m_FrameSize = ID3v2Utils.ReadInt32SyncSafe(stream);
m_FrameSizeExcludingAdditions = m_FrameSize;
byte byte0 = stream.Read1();
byte byte1 = stream.Read1();
bool hasDataLengthIndicator = ((byte1 & 0x01) == 0x01);
usesUnsynchronization = ((byte1 & 0x03) == 0x03);
if (hasDataLengthIndicator)
{
m_FrameSizeExcludingAdditions -= 4;
stream.Seek(4, SeekOrigin.Current); // skip data length indicator
}
if (usesUnsynchronization)
{
stream = ID3v2Utils.ReadUnsynchronizedStream(stream, m_FrameSize);
}
// TODO - finish parsing
}
if (IsCompressed)
{
stream = ID3v2Utils.DecompressFrame(stream, FrameSizeExcludingAdditions);
IsCompressed = false;
DecompressedSize = 0;
m_FrameSizeExcludingAdditions = (int)stream.Length;
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 1)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (bytesLeft >= 3)
{
LanguageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
bytesLeft -= 3;
if (bytesLeft > 0)
{
Value = ID3v2Utils.ReadString(TextEncoding, stream, bytesLeft);
bytesLeft = 0;
}
}
else
{
LanguageCode = "eng";
}
}
else
{
TextEncoding = EncodingType.ISO88591;
LanguageCode = "eng";
}
// Seek past any unread bytes
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 4)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
MimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
FileName = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft > 0)
{
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft > 0)
{
EncapsulatedObject = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
}
}
// Seek to end of frame
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
Reset();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 1)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
string priceString = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (!string.IsNullOrEmpty(priceString))
{
foreach (string priceItem in priceString.Split('/'))
{
if (priceItem.Length > 3)
{
decimal price;
string pricePart = priceItem.Substring(3, priceItem.Length - 3);
if (decimal.TryParse(pricePart, System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out price))
{
IPriceInformation priceInfo = new PriceInformation();
priceInfo.CurrencyCode = priceItem.Substring(0, 3);
priceInfo.Price = price;
_priceList.Add(priceInfo);
}
}
}
}
if (bytesLeft > 0)
{
string validUntil = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 8);
bytesLeft -= 8;
if (validUntil.Length == 8)
{
validUntil = string.Format("{0}-{1}-{2}", validUntil.Substring(0, 4),
validUntil.Substring(4, 2), validUntil.Substring(6, 2));
DateTime.TryParse(validUntil, out _validUntil);
}
if (bytesLeft > 0)
{
ContactUrl = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
ReceivedAs = (ReceivedAs)stream.Read1(ref bytesLeft);
NameOfSeller = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
SellerLogoMimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
SellerLogo = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
}
}
}
if (bytesLeft != 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public static string ReadString(EncodingType textEncoding, Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
string returnValue;
List<byte> byteList = new List<byte>();
if (textEncoding == EncodingType.ISO88591)
{
byte readByte = stream.Read1();
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
}
returnValue = ByteUtils.ISO88591GetString(byteList.ToArray());
}
else if (textEncoding == EncodingType.Unicode)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
byte2 = stream.Read1();
byteList.Add(byte2);
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, decode as the appropriate Unicode type.
// If no BOM is present use Little Endian Unicode.
if (byteArray[0] == 0xFF && byteArray[1] == 0xFE)
returnValue = Encoding.Unicode.GetString(byteArray, 2, byteArray.Length - 2);
else if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
else
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
else
{
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF16BE)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
byte2 = stream.Read1();
byteList.Add(byte2);
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, remove before decoding.
if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
else
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
else
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF8)
{
byte readByte = stream.Read1();
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
}
returnValue = Encoding.UTF8.GetString(byteList.ToArray());
}
else
{
// Most likely bad data
string msg = string.Format("Text Encoding '{0}' unknown at position {1}", textEncoding, stream.Position);
Trace.WriteLine(msg);
return "";
}
returnValue = returnValue.TrimEnd('\0');
return returnValue;
}
public void Read(TagReadingInfo tagReadingInfo, ref Stream stream)
{
// TODO: Some tags have the length INCLUDE the extra ten bytes of the tag header.
// Handle this (don't corrupt MP3 on rewrite)
m_TagVersion = tagReadingInfo.TagVersion;
bool usesUnsynchronization = ((tagReadingInfo.TagVersionOptions & TagVersionOptions.Unsynchronized) == TagVersionOptions.Unsynchronized);
if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v23)
{
if (!usesUnsynchronization)
{
m_FrameSize = stream.ReadInt32();
}
else
{
m_FrameSize = ID3v2Utils.ReadInt32Unsynchronized(stream);
}
m_FrameSizeExcludingAdditions = m_FrameSize;
byte byte0 = stream.Read1();
byte byte1 = stream.Read1();
// First byte
IsTagAlterPreservation = ((byte0 & 0x80) == 0x80);
IsFileAlterPreservation = ((byte0 & 0x40) == 0x40);
IsReadOnly = ((byte0 & 0x20) == 0x20);
// Second byte
IsCompressed = ((byte1 & 0x80) == 0x80);
bool tmpIsEncrypted = ((byte1 & 0x40) == 0x40);
bool tmpIsGroupingIdentity = ((byte1 & 0x20) == 0x20);
// Additional bytes
// Compression
if (IsCompressed)
{
DecompressedSize = stream.ReadInt32();
m_FrameSizeExcludingAdditions -= 4;
}
else
{
DecompressedSize = 0;
}
// Encryption
if (tmpIsEncrypted)
{
EncryptionMethod = stream.Read1();
m_FrameSizeExcludingAdditions -= 1;
}
else
{
EncryptionMethod = null;
}
// Grouping Identity
if (tmpIsGroupingIdentity)
{
GroupingIdentity = stream.Read1();
m_FrameSizeExcludingAdditions -= 1;
}
else
{
GroupingIdentity = null;
}
if (usesUnsynchronization)
{
stream = ID3v2Utils.ReadUnsynchronizedStream(stream, m_FrameSize);
}
}
else if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v22)
{
if (!usesUnsynchronization)
{
m_FrameSize = stream.ReadInt24();
}
else
{
m_FrameSize = ID3v2Utils.ReadInt24Unsynchronized(stream);
}
if ((tagReadingInfo.TagVersionOptions & TagVersionOptions.AddOneByteToSize) == TagVersionOptions.AddOneByteToSize)
{
m_FrameSize++;
}
m_FrameSizeExcludingAdditions = m_FrameSize;
// These fields are not supported in ID3v2.2
IsTagAlterPreservation = false;
IsFileAlterPreservation = false;
IsReadOnly = false;
IsCompressed = false;
DecompressedSize = 0;
EncryptionMethod = null;
GroupingIdentity = null;
if (usesUnsynchronization)
{
stream = ID3v2Utils.ReadUnsynchronizedStream(stream, m_FrameSize);
}
}
else if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v24)
{
if ((tagReadingInfo.TagVersionOptions & TagVersionOptions.UseNonSyncSafeFrameSizeID3v24) == TagVersionOptions.UseNonSyncSafeFrameSizeID3v24)
{
m_FrameSize = stream.ReadInt32();
}
else
{
m_FrameSize = ID3v2Utils.ReadInt32SyncSafe(stream);
}
m_FrameSizeExcludingAdditions = m_FrameSize;
byte byte0 = stream.Read1();
byte byte1 = stream.Read1();
bool hasDataLengthIndicator = ((byte1 & 0x01) == 0x01);
usesUnsynchronization = ((byte1 & 0x03) == 0x03);
if (hasDataLengthIndicator)
{
m_FrameSizeExcludingAdditions -= 4;
stream.Seek(4, SeekOrigin.Current); // skip data length indicator
}
if (usesUnsynchronization)
{
stream = ID3v2Utils.ReadUnsynchronizedStream(stream, m_FrameSize);
}
// TODO - finish parsing
}
if (IsCompressed)
{
stream = ID3v2Utils.DecompressFrame(stream, FrameSizeExcludingAdditions);
IsCompressed = false;
DecompressedSize = 0;
m_FrameSizeExcludingAdditions = (int)stream.Length;
}
}
public static string ReadString(EncodingType textEncoding, Stream stream, ref int bytesLeft)
{
if (bytesLeft <= 0)
{
//String msg = String.Format("ReadString (unknown length) called with {0} bytes left at position {1}", bytesLeft, stream.Position);
//Trace.WriteLine(msg);
return string.Empty;
}
string returnValue;
List<byte> byteList = new List<byte>();
if (textEncoding == EncodingType.ISO88591)
{
byte readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return "";
}
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
if (readByte != 0) byteList.Add(readByte);
return ByteUtils.ISO88591GetString(byteList.ToArray());
}
}
returnValue = ByteUtils.ISO88591GetString(byteList.ToArray());
}
else if (textEncoding == EncodingType.Unicode)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return "";
}
byte2 = stream.Read1();
byteList.Add(byte2);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
break;
//return "";
}
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, decode as the appropriate Unicode type.
// If no BOM is present use Little Endian Unicode.
if (byteArray[0] == 0xFF && byteArray[1] == 0xFE)
returnValue = Encoding.Unicode.GetString(byteArray, 2, byteArray.Length - 2);
else if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
else
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
else
{
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF16BE)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return "";
}
byte2 = stream.Read1();
byteList.Add(byte2);
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
break;
//return "";
}
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, remove before decoding.
if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
else
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
else
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF8)
{
byte readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return "";
}
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
--bytesLeft;
if (bytesLeft == 0)
{
//String msg = String.Format("End of frame reached while reading unknown length string at position {0}", stream.Position);
//Trace.WriteLine(msg);
return "";
}
}
returnValue = Encoding.UTF8.GetString(byteList.ToArray());
}
else
{
// Most likely bad data
string msg = string.Format("Text Encoding '{0}' unknown at position {1}", textEncoding, stream.Position);
Trace.WriteLine(msg);
return "";
}
returnValue = returnValue.TrimEnd('\0');
return returnValue;
}
public static string ReadString(EncodingType textEncoding, Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
string returnValue;
List <byte> byteList = new List <byte>();
if (textEncoding == EncodingType.ISO88591)
{
byte readByte = stream.Read1();
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
}
returnValue = ByteUtils.ISO88591GetString(byteList.ToArray());
}
else if (textEncoding == EncodingType.Unicode)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
byte2 = stream.Read1();
byteList.Add(byte2);
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, decode as the appropriate Unicode type.
// If no BOM is present use Little Endian Unicode.
if (byteArray[0] == 0xFF && byteArray[1] == 0xFE)
{
returnValue = Encoding.Unicode.GetString(byteArray, 2, byteArray.Length - 2);
}
else if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
}
else
{
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
}
else
{
returnValue = Encoding.Unicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF16BE)
{
byte byte1;
byte byte2;
do
{
byte1 = stream.Read1();
byteList.Add(byte1);
byte2 = stream.Read1();
byteList.Add(byte2);
} while (byte1 != 0 || byte2 != 0);
byte[] byteArray = byteList.ToArray();
if (byteArray.Length >= 2)
{
// If BOM is part of the string, remove before decoding.
if (byteArray[0] == 0xFE && byteArray[1] == 0xFF)
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 2, byteArray.Length - 2);
}
else
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
}
else
{
returnValue = Encoding.BigEndianUnicode.GetString(byteArray, 0, byteArray.Length);
}
}
else if (textEncoding == EncodingType.UTF8)
{
byte readByte = stream.Read1();
while (readByte != 0)
{
byteList.Add(readByte);
readByte = stream.Read1();
}
returnValue = Encoding.UTF8.GetString(byteList.ToArray());
}
else
{
// Most likely bad data
string msg = string.Format("Text Encoding '{0}' unknown at position {1}", textEncoding, stream.Position);
Trace.WriteLine(msg);
return("");
}
returnValue = returnValue.TrimEnd('\0');
return(returnValue);
}
public static byte[] ReadUnsynchronized(Stream stream, int size)
{
using (MemoryStream byteList = new MemoryStream(size))
{
for (int i = 0; i < size; i++)
{
byte myByte = stream.Read1();
byteList.WriteByte(myByte);
if (myByte == 0xFF)
{
myByte = stream.Read1(); // skip 0x00
if (myByte != 0)
{
byteList.WriteByte(myByte);
i++;
}
}
}
return byteList.ToArray();
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
Items.Clear();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 1)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (bytesLeft >= 3)
{
LanguageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
bytesLeft -= 3;
if (bytesLeft >= 2)
{
TimestampFormat = (TimestampFormat)stream.Read1(ref bytesLeft);
ContentType = (TextContentType)stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
ContentDescriptor = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
while (bytesLeft > 0)
{
string lyrics = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft >= 4)
{
SynchronizedTextItem textItem = new SynchronizedTextItem();
textItem.Text = lyrics;
textItem.Timestamp = stream.ReadInt32();
bytesLeft -= 4;
Items.Add(textItem);
}
}
}
else
{
// Incomplete frame
ContentDescriptor = "";
}
}
else
{
// Incomplete frame
TimestampFormat = TimestampFormat.Milliseconds;
ContentType = TextContentType.Other;
ContentDescriptor = "";
}
}
else
{
// Incomplete frame
LanguageCode = "eng";
TimestampFormat = TimestampFormat.Milliseconds;
ContentType = TextContentType.Other;
ContentDescriptor = "";
}
}
else
{
// Incomplete frame
TextEncoding = EncodingType.ISO88591;
LanguageCode = "eng";
TimestampFormat = TimestampFormat.Milliseconds;
ContentType = TextContentType.Other;
ContentDescriptor = "";
}
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
// RVAD/RVA2
/*Double original = -65534;
* Double newVal = Math.Log10(1 + original/65535.0)*20.0*512.0;
* Double original2 = Math.Pow(10, newVal/(20.0*512.0));
* original2 = original2 - 1;
* original2 *= 65535.0;*/
/*Double original = 10000;
* Double newVal = Math.Log10(1 + original / 65535.0);
* Double original2 = Math.Pow(10, newVal);
* original2 = original2 - 1;
* original2 *= 65535.0;*/
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
// todo: there needs to be some kind of a test to see if this is RVAD/RVA2 format, too
// much varying implementation in 2.3 and 2.4
bool isRVA2 = (_frameHeader.TagVersion == ID3v2TagVersion.ID3v24);
if (isRVA2)
{
// sometimes "identification" is completely ommitted... grr
Identification = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
while (bytesLeft >= 3)
{
// TODO: Implementation not complete
byte channelType = stream.Read1(ref bytesLeft);
//if (channelType == 16) break; // Invalid, probably stored as an ID3v2.3 RVAD frame
// TODO: some kind of switch.. maybe a new internal enum
short volumeAdjustment = stream.ReadInt16(ref bytesLeft);
if (bytesLeft > 0)
{
// sometimes represented as BITS representing peak.. seriously.
byte bytesRepresentingPeak = stream.Read1(ref bytesLeft);
if (bytesRepresentingPeak == 0)
{
break;
}
if (bytesLeft >= bytesRepresentingPeak)
{
// TODO: Finish implementation
byte[] peakVolume = stream.Read(bytesRepresentingPeak);
bytesLeft -= peakVolume.Length;
}
else
{
break;
}
}
}
if (bytesLeft > 0)
{
//Trace.WriteLine("Invalid RVA2 frame");
//stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
// Try to read it like an ID3v2.3 RVAD frame
stream.Seek(bytesLeft - _frameHeader.FrameSizeExcludingAdditions, SeekOrigin.Current);
bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
isRVA2 = false;
}
else
{
// TODO
//MessageBox.Show("valid RVA2 frame, omg!");
}
}
// ID3v2.2, ID3v2.3, or mal-formed ID3v2.4
if (isRVA2 == false)
{
byte incrementDecrement = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
byte bitsUsedForVolumeDescription = stream.Read1(ref bytesLeft);
int bytesUsedForVolumeDescription = bitsUsedForVolumeDescription / 8;
// TODO: (may be useful for testing which implementation)
// if bits used for volume description is > 64, don't bother
// Relative volume change, right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 0) ? 1 : -1);
}
// Relative volume change, left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 1) ? 1 : -1);
}
// Peak volume right
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 2) ? 1 : -1);
}
// Relative volume change, left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 3) ? 1 : -1);
}
// Peak volume right back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackRightPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Peak volume left back
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
BackLeftPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 4) ? 1 : -1);
}
// Peak volume center
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
FrontCenterPeak = ByteUtils.ConvertToInt64(byteArray);
}
// Relative volume change, bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferAdjustment = ByteUtils.ConvertToInt64(byteArray) * (ByteUtils.IsBitSet(incrementDecrement, 5) ? 1 : -1);
}
// Peak volume bass
if (bytesLeft >= bytesUsedForVolumeDescription)
{
byte[] byteArray = stream.Read(bytesUsedForVolumeDescription, ref bytesLeft);
SubwooferPeak = ByteUtils.ConvertToInt64(byteArray);
}
}
}
// Skip past the rest of the frame
if (bytesLeft > 0)
{
Trace.WriteLine("Invalid RVA2/RVAD/RVA frame");
stream.Seek(bytesLeft, SeekOrigin.Current);
//bytesLeft = 0;
}
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
UserEmail = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 0)
{
Rating = stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
byte[] playCount = stream.Read(bytesLeft);
PlayCount = ByteUtils.ConvertToInt64(playCount);
}
else
{
PlayCount = 0;
}
}
else
{
Rating = 0;
PlayCount = 0;
}
}
else
{
UserEmail = null;
Rating = 0;
PlayCount = 0;
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_languageItems.Clear();
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 4)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
// This could be implemented many ways
// engfraspa etc
// eng 0x00 fra 0x00 spa 0x00 etc
// English
// English 0x00 French 0x00 Spanish 0x00
// TODO: Finish implementation
string languageCode = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (languageCode.Length != 3)
{
if (languageCode.ToLower() == "english" || languageCode.ToLower() == "en")
{
Items.AddNew().LanguageCode = "eng";
}
else
{
foreach (KeyValuePair<string, string> kvp in LanguageHelper.Languages)
{
if (kvp.Value.ToLower() == languageCode.ToLower())
{
Items.AddNew().LanguageCode = kvp.Key;
break;
}
}
}
}
else
{
Items.AddNew().LanguageCode = languageCode;
}
}
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
// Some taggers write 0 byte sized frames (which is explicitly forbidden by the spec)
if (_frameHeader.FrameSizeExcludingAdditions >= 1)
{
TextEncoding = (EncodingType)stream.Read1();
Value = ID3v2Utils.ReadString(_textEncoding, stream, _frameHeader.FrameSizeExcludingAdditions - 1);
}
else
{
//String msg = String.Format("Under-sized ({0} bytes) text frame at position {1}", m_FrameHeader.FrameSizeExcludingAdditions, stream.Position);
//Trace.WriteLine(msg);
TextEncoding = EncodingType.ISO88591;
Value = "";
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
// Read header
_frameHeader.Read(tagReadingInfo, ref stream);
// Read frame data
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 6) // note: 6 was chosen arbitrarily
{
// Read text encoding
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v22)
{
// TODO: Do something with this?
string imageFormat = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
bytesLeft -= 3;
}
else
{
// Read MIME type
MimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
}
// Read picture type
PictureType = (PictureType)stream.Read1(ref bytesLeft);
// Short description
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
// Picture data
if (bytesLeft > 0)
{
byte[] pictureData = stream.Read(bytesLeft);
bytesLeft = 0;
_readingTag = true;
try
{
_pictureCached = false;
PictureData = pictureData;
}
finally
{
_readingTag = false;
}
}
else
{
// Incomplete frame
PictureData = null;
}
}
else
{
// Incomplete frame
TextEncoding = EncodingType.ISO88591;
Description = null;
MimeType = null;
PictureType = PictureType.CoverFront;
PictureData = null;
}
// Seek to end of frame
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
// Read header
_frameHeader.Read(tagReadingInfo, ref stream);
// Read frame data
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft >= 6) // note: 6 was chosen arbitrarily
{
// Read text encoding
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (tagReadingInfo.TagVersion == ID3v2TagVersion.ID3v22)
{
// TODO: Do something with this?
string imageFormat = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
bytesLeft -= 3;
}
else
{
// Read MIME type
MimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
}
// Read picture type
PictureType = (PictureType)stream.Read1(ref bytesLeft);
// Short description
Description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
// Picture data
if (bytesLeft > 0)
{
byte[] pictureData = stream.Read(bytesLeft);
bytesLeft = 0;
_readingTag = true;
try
{
_pictureCached = false;
PictureData = pictureData;
}
finally
{
_readingTag = false;
}
}
else
{
// Incomplete frame
PictureData = null;
}
}
else
{
// Incomplete frame
TextEncoding = EncodingType.ISO88591;
Description = null;
MimeType = null;
PictureType = PictureType.CoverFront;
PictureData = null;
}
// Seek to end of frame
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
if (bytesLeft > 0)
{
MimeType = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, ref bytesLeft);
if (bytesLeft > 1)
{
byte flags = stream.Read1(ref bytesLeft);
_isMpegOrAac = ((flags & 0x01) == 0x00);
EquivalentText = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (bytesLeft > 0)
{
_audioData = stream.Read(bytesLeft);
bytesLeft = 0;
}
}
else
{
EquivalentText = null;
_audioData = null;
}
}
else
{
MimeType = null;
EquivalentText = null;
_audioData = null;
}
}
else
{
TextEncoding = EncodingType.ISO88591;
MimeType = null;
EquivalentText = null;
_audioData = null;
}
if (bytesLeft > 0)
{
stream.Seek(bytesLeft, SeekOrigin.Current);
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
// Sometimes a frame size of "0" comes through (which is explicitly forbidden in spec)
if (_frameHeader.FrameSizeExcludingAdditions >= 1)
{
TextEncoding = (EncodingType)stream.Read1();
// TODO: A common mis-implementation is to exclude the language code and description
// Haven't decided how to handle this yet. Maybe if a lookup to the language table fails,
// the rest of the frame should be treated as suspicious.
if (_frameHeader.FrameSizeExcludingAdditions >= 4)
{
string languageCode = ID3v2Utils.ReadString(EncodingType.ISO88591, stream, 3);
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions - 1 - 3;
string description = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
bool invalidFrame = false;
if (LanguageHelper.Languages.ContainsKey(languageCode.ToLower()) == false && languageCode.ToLower() != "xxx")
{
// most likely, it's en\0, or some other funk
if (languageCode.StartsWith("en"))
{
languageCode = "";
}
invalidFrame = true;
if (bytesLeft == 0)
{
Description = "";
}
else
{
Description = languageCode + description;
}
LanguageCode = "eng";
}
else
{
LanguageCode = languageCode;
Description = description;
}
if (bytesLeft > 0)
{
Value = ID3v2Utils.ReadString(TextEncoding, stream, bytesLeft);
}
else
{
if (invalidFrame)
{
if (languageCode.Contains("\0"))
{
// forget it, too messed up.
Value = "";
}
else
{
Value = languageCode + description;
}
}
else
{
Value = "";
}
}
}
else
{
string msg = string.Format("Under-sized ({0} bytes) COMM frame at position {1}", _frameHeader.FrameSizeExcludingAdditions, stream.Position);
Trace.WriteLine(msg);
LanguageCode = "eng";
Value = "";
}
}
else
{
string msg = string.Format("Under-sized ({0} bytes) COMM frame at position {1}", _frameHeader.FrameSizeExcludingAdditions, stream.Position);
Trace.WriteLine(msg);
LanguageCode = "eng";
Value = "";
}
}
public override void Read(TagReadingInfo tagReadingInfo, Stream stream)
{
_frameHeader.Read(tagReadingInfo, ref stream);
_involvedPersons.Clear();
int bytesLeft = _frameHeader.FrameSizeExcludingAdditions;
if (bytesLeft > 0)
{
TextEncoding = (EncodingType)stream.Read1(ref bytesLeft);
while (bytesLeft > 0)
{
string involvement = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
string name = ID3v2Utils.ReadString(TextEncoding, stream, ref bytesLeft);
if (!string.IsNullOrEmpty(involvement) || !string.IsNullOrEmpty(name))
{
IInvolvedPerson involvedPerson = _involvedPersons.AddNew();
involvedPerson.Involvement = involvement;
involvedPerson.Name = name;
}
}
}
}
