| public abstract Seek ( long offset, SeekOrigin origin ) : long | ||
| offset | long | |
| origin | SeekOrigin | |
| Résultat | long | |
public void Save(Stream output)
{
BinaryWriter writer = new BinaryWriter(output);
writer.Write(this.version);
writer.Write((int)0);
writer.Write((int)0);
// Double the string length since it's UTF16
writer.Write((byte)(this.partName.Length * 2));
MadScience.StreamHelpers.WriteStringUTF16(output, false, this.partName);
writer.Write(this.blendType);
this.blendTgi.Save(output);
writer.Write((uint)this.geomBoneEntries.Count);
for (int i = 0; i < this.geomBoneEntries.Count; i++)
{
this.geomBoneEntries[i].Save(output);
}
uint tgiOffset = (uint)output.Position - 8;
// Why is this +12? I dunno. :)
this.keytable.size = 8;
this.keytable.Save(output);
output.Seek(4, SeekOrigin.Begin);
writer.Write(tgiOffset);
writer.Write(this.keytable.size);
writer = null;
}
public bool Read(Id3Tag tag, Stream mp3Stream)
{
//Check wether the file contains an Id3v1 tag--------------------------------
mp3Stream.Seek( -128 , SeekOrigin.End);
byte[] b = new byte[3];
mp3Stream.Read( b, 0, 3 );
mp3Stream.Seek(0, SeekOrigin.Begin);
string tagS = Encoding.ASCII.GetString(b);
if(tagS != "TAG")
return false;
mp3Stream.Seek( - 128 + 3, SeekOrigin.End );
//Parse the tag -)------------------------------------------------
tag.AddTitle(Read(mp3Stream, 30));
tag.AddArtist(Read(mp3Stream, 30));
tag.AddAlbum(Read(mp3Stream, 30));
//------------------------------------------------
tag.AddYear(Read(mp3Stream, 4));
tag.AddComment(Read(mp3Stream, 30));
//string trackNumber;
mp3Stream.Seek(- 2, SeekOrigin.Current);
b = new byte[2];
mp3Stream.Read(b, 0, 2);
if (b[0] == 0)
tag.AddTrack(b[1].ToString());
byte genreByte = (byte) mp3Stream.ReadByte();
mp3Stream.Seek(0, SeekOrigin.Begin);
tag.AddGenre(TagGenres.Get(genreByte));
return true;
}
/// <summary>
/// Reads a generic Pokémon container from a Stream.
/// Those containers are the ones that starts with "GR", "MM", "AD" and so on...
/// </summary>
/// <param name="data">Stream with container data</param>
/// <returns></returns>
public static OContainer load(Stream data)
{
BinaryReader input = new BinaryReader(data);
OContainer output = new OContainer();
IOUtils.readString(input, 0, 2); //Magic
ushort sectionCount = input.ReadUInt16();
for (int i = 0; i < sectionCount; i++)
{
OContainer.fileEntry entry = new OContainer.fileEntry();
data.Seek(4 + (i * 4), SeekOrigin.Begin);
uint startOffset = input.ReadUInt32();
uint endOffset = input.ReadUInt32();
uint length = endOffset - startOffset;
data.Seek(startOffset, SeekOrigin.Begin);
byte[] buffer = new byte[length];
input.Read(buffer, 0, (int)length);
entry.data = buffer;
output.content.Add(entry);
}
data.Close();
return output;
}
public HvaReader(Stream s)
{
// Index swaps for transposing a matrix
var ids = new byte[] { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14 };
s.Seek(16, SeekOrigin.Begin);
FrameCount = s.ReadUInt32();
LimbCount = s.ReadUInt32();
// Skip limb names
s.Seek(16 * LimbCount, SeekOrigin.Current);
Transforms = new float[16 * FrameCount * LimbCount];
for (var j = 0; j < FrameCount; j++)
for (var i = 0; i < LimbCount; i++)
{
// Convert to column-major matrices and add the final matrix row
var c = 16 * (LimbCount * j + i);
Transforms[c + 3] = 0;
Transforms[c + 7] = 0;
Transforms[c + 11] = 0;
Transforms[c + 15] = 1;
for (var k = 0; k < 12; k++)
Transforms[c + ids[k]] = s.ReadFloat();
}
}
public void Write(Tag tag, Stream apeStream, Stream tempStream) {
ByteBuffer tagBuffer = tc.Create(tag);
if (!TagExists(apeStream)) {
apeStream.Seek(0, SeekOrigin.End);
apeStream.Write(tagBuffer.Data, 0, tagBuffer.Capacity);
} else {
apeStream.Seek( -32 + 8 , SeekOrigin.End);
//Version
byte[] b = new byte[4];
apeStream.Read( b , 0, b.Length);
int version = Utils.GetNumber(b, 0, 3);
if(version != 2000) {
throw new CannotWriteException("APE Tag other than version 2.0 are not supported");
}
//Size
b = new byte[4];
apeStream.Read( b , 0, b.Length);
long oldSize = Utils.GetLongNumber(b, 0, 3) + 32;
int tagSize = tagBuffer.Capacity;
apeStream.Seek(-oldSize, SeekOrigin.End);
apeStream.Write(tagBuffer.Data, 0, tagBuffer.Capacity);
if(oldSize > tagSize) {
//Truncate the file
apeStream.SetLength(apeStream.Length - (oldSize-tagSize));
}
}
}
public static int WriteSparse(Stream f,byte[] buf ,int len)
{
int l1=0, l2=0;
int ret;
for (l1 = 0; l1 < len && buf[l1] == 0; l1++) {}
for (l2 = 0; l2 < len-l1 && buf[len-(l2+1)] == 0; l2++) {}
lastByte = buf[len-1];
if (l1 == len || l2 > 0)
lastSparse=1;
if (l1 > 0)
f.Seek(l1, SeekOrigin.Current);
if (l1 == len)
return len;
f.Write(buf, l1, len - (l1+l2));
ret = len - (l1+l2);
if (ret == -1 || ret == 0)
return ret;
else if (ret != (len - (l1+l2)))
return (l1+ret);
if (l2 > 0)
f.Seek(l2, SeekOrigin.Current);
return len;
}
/// <summary>
/// Reads a DARC archive.
/// </summary>
/// <param name="data">Stream of the data</param>
/// <returns>The container data</returns>
public static OContainer load(Stream data)
{
OContainer output = new OContainer();
BinaryReader input = new BinaryReader(data);
string darcMagic = IOUtils.readStringWithLength(input, 4);
ushort endian = input.ReadUInt16();
ushort headerLength = input.ReadUInt16();
uint version = input.ReadUInt32();
uint fileSize = input.ReadUInt32();
uint tableOffset = input.ReadUInt32();
uint tableLength = input.ReadUInt32();
uint dataOffset = input.ReadUInt32();
data.Seek(tableOffset, SeekOrigin.Begin);
fileEntry root = getEntry(input);
int baseOffset = (int)data.Position;
int namesOffset = (int)(tableOffset + root.length * 0xc);
string currDir = null;
for (int i = 0; i < root.length - 1; i++)
{
data.Seek(baseOffset + i * 0xc, SeekOrigin.Begin);
fileEntry entry = getEntry(input);
if ((entry.flags & 1) > 0)
{
//Folder
int index = i;
currDir = null;
for (;;)
{
uint parentIndex = entry.offset;
currDir = getName(input, entry.nameOffset + namesOffset) + "/" + currDir;
if (parentIndex == 0 || parentIndex == index) break;
data.Seek(baseOffset + parentIndex * 0xc, SeekOrigin.Begin);
entry = getEntry(input);
index = (int)parentIndex;
}
continue;
}
data.Seek(entry.offset, SeekOrigin.Begin);
byte[] buffer = new byte[entry.length];
data.Read(buffer, 0, buffer.Length);
OContainer.fileEntry file = new OContainer.fileEntry();
file.name = currDir + getName(input, entry.nameOffset + namesOffset);
file.data = buffer;
output.content.Add(file);
}
data.Close();
return output;
}
public bool Open(Stream fs)
{
var intBytes = new byte[4];
Header = MarshalUtil.ReadStruct<CIAHeader>(fs); //read header
CertificateChainOffset = Marshal.SizeOf(Header) + (long)Header.PaddingLength;
TicketOffset = CertificateChainOffset + Header.CertificateChainLength;
if (TicketOffset % 64 != 0)
TicketOffset += (64 - TicketOffset % 64);
TMDOffset = TicketOffset + Header.TicketLength;
if (TMDOffset % 64 != 0)
TMDOffset += (64 - TMDOffset % 64);
ContentOffset = TMDOffset + Header.TMDLength; ;
if (ContentOffset % 64 != 0)
ContentOffset += (64 - ContentOffset % 64);
MetaOffset = ContentOffset + (long)Header.ContentLength;
if (MetaOffset % 64 != 0)
MetaOffset += (64 - MetaOffset % 64);
fs.Seek(TicketOffset, SeekOrigin.Begin);
TicketContext = new TicketContext();
if (!TicketContext.Open(fs))
{
errorMessage = TicketContext.GetErrorMessage();
return false;
}
fs.Seek(CertificateChainOffset, SeekOrigin.Begin);
CertificatesContext = new CertificatesContext();
if (!CertificatesContext.Open(fs))
{
errorMessage = CertificatesContext.GetErrorMessage();
return false;
}
fs.Seek(TMDOffset, SeekOrigin.Begin);
TMDContext = new TMDContext();
if (!TMDContext.Open(fs))
{
errorMessage = TMDContext.GetErrorMessage();
return false;
}
if (Header.MetaLength > 0)
{
fs.Seek(MetaOffset, SeekOrigin.Begin);
MetaHeaderEntries = new ArrayList();
var metaHeaderEntry = MarshalUtil.ReadStruct<CIAMetaHeaderEntry>(fs);
while (metaHeaderEntry.Type != 0)
{
MetaHeaderEntries.Add(metaHeaderEntry);
metaHeaderEntry = MarshalUtil.ReadStruct<CIAMetaHeaderEntry>(fs);
}
fs.Seek(MetaOffset + 0x400, SeekOrigin.Begin); //Jump to the header
ICN = new ICNContext();
ICN.Open(fs);
}
return true;
}
public bool Open(Stream fs)
{
StartOffset = fs.Position;
Header = MarshalUtil.ReadStruct<ICNHeader>(fs); //read header
fs.Seek(StartOffset + 0x2000, SeekOrigin.Begin); //Jump to the icons
fs.Seek(0x40, SeekOrigin.Current); //skip header
SmallIcon = ImageUtil.ReadImageFromStream(fs, 24, 24, ImageUtil.PixelFormat.RGB565);
LargeIcon = ImageUtil.ReadImageFromStream(fs, 48, 48, ImageUtil.PixelFormat.RGB565);
return true;
}
/// <summary>
/// 値をバイト配列として読み取ります。
/// </summary>
/// <param name="src">値を読み取るストリーム。</param>
/// <returns>値となるバイト配列。</returns>
public byte[] Read( Stream src )
{
var position = src.Position;
src.Seek( this.Position, SeekOrigin.Begin );
var value = src.ReadBytes( this.Length );
src.Seek( position, SeekOrigin.Begin );
return value;
}
/// <summary>
/// Loads a Fantasy Life ZTEX texture from a Stream.
/// </summary>
/// <param name="data">The Stream with the data</param>
/// <returns>The list of textures</returns>
public static List<RenderBase.OTexture> load(Stream data)
{
List<RenderBase.OTexture> textures = new List<RenderBase.OTexture>();
BinaryReader input = new BinaryReader(data);
string ztexMagic = IOUtils.readString(input, 0, 4);
ushort textureCount = input.ReadUInt16();
input.ReadUInt16();
input.ReadUInt32();
List<textureEntry> entries = new List<textureEntry>();
for (int i = 0; i < textureCount; i++)
{
textureEntry entry = new textureEntry();
entry.name = IOUtils.readString(input, (uint)(0xc + (i * 0x58)));
data.Seek(0xc + (i * 0x58) + 0x40, SeekOrigin.Begin);
input.ReadUInt32();
entry.offset = input.ReadUInt32();
input.ReadUInt32();
entry.length = input.ReadUInt32();
entry.width = input.ReadUInt16();
entry.height = input.ReadUInt16();
input.ReadByte();
entry.format = input.ReadByte();
input.ReadUInt16();
entries.Add(entry);
}
foreach (textureEntry entry in entries)
{
data.Seek(entry.offset, SeekOrigin.Begin);
byte[] buffer = new byte[entry.length];
data.Read(buffer, 0, buffer.Length);
Bitmap bmp = null;
switch (entry.format)
{
case 1: bmp = TextureCodec.decode(buffer, entry.width, entry.height, RenderBase.OTextureFormat.rgb565); break;
case 5: bmp = TextureCodec.decode(buffer, entry.width, entry.height, RenderBase.OTextureFormat.rgba4); break;
case 9: bmp = TextureCodec.decode(buffer, entry.width, entry.height, RenderBase.OTextureFormat.rgba8); break;
case 0x18: bmp = TextureCodec.decode(buffer, entry.width, entry.height, RenderBase.OTextureFormat.etc1); break;
case 0x19: bmp = TextureCodec.decode(buffer, entry.width, entry.height, RenderBase.OTextureFormat.etc1a4); break;
}
textures.Add(new RenderBase.OTexture(bmp, entry.name));
}
data.Close();
return textures;
}
public EncodingInfo Read( Stream raf )
{
EncodingInfo info = new EncodingInfo();
//Begin info fetch-------------------------------------------
if ( raf.Length == 0 ) {
//Empty File
throw new CannotReadException("File is empty");
}
raf.Seek( 0 , SeekOrigin.Begin);
//MP+ Header string
byte[] b = new byte[4];
raf.Read(b, 0, b.Length);
string mpc = new string(System.Text.Encoding.ASCII.GetChars(b));
if (mpc != "MAC ") {
throw new CannotReadException("'MAC ' Header not found");
}
b = new byte[4];
raf.Read(b, 0, b.Length);
int version = Utils.GetNumber(b, 0,3);
if(version < 3970)
throw new CannotReadException("Monkey Audio version <= 3.97 is not supported");
b = new byte[44];
raf.Read(b, 0, b.Length);
MonkeyDescriptor md = new MonkeyDescriptor(b);
b = new byte[24];
raf.Read(b, 0, b.Length);
MonkeyHeader mh = new MonkeyHeader(b);
raf.Seek(md.RiffWavOffset, SeekOrigin.Begin);
b = new byte[12];
raf.Read(b, 0, b.Length);
WavRIFFHeader wrh = new WavRIFFHeader(b);
if(!wrh.Valid)
throw new CannotReadException("No valid RIFF Header found");
b = new byte[24];
raf.Read(b, 0, b.Length);
WavFormatHeader wfh = new WavFormatHeader(b);
if(!wfh.Valid)
throw new CannotReadException("No valid WAV Header found");
info.Length = mh.Length;
info.ChannelNumber = wfh.ChannelNumber ;
info.SamplingRate = wfh.SamplingRate ;
info.Bitrate = ComputeBitrate(info.Length, raf.Length) ;
info.EncodingType = "Monkey Audio v" + (((double)version)/1000)+", compression level "+mh.CompressionLevel;
info.ExtraEncodingInfos = "";
return info;
}
public Id3v2Tag Read(Stream mp3Stream)
{
Id3v2Tag tag;
byte[] b = new byte[3];
mp3Stream.Read(b, 0, b.Length);
mp3Stream.Seek(0, SeekOrigin.Begin);
string ID3 = new string(System.Text.Encoding.ASCII.GetChars(b));
if (ID3 != "ID3") {
throw new CannotReadException("Not an ID3 tag");
}
//Begins tag parsing ---------------------------------------------
mp3Stream.Seek(3, SeekOrigin.Begin);
//----------------------------------------------------------------------------
//Version du tag ID3v2.xx.xx
string versionHigh=mp3Stream.ReadByte() +"";
string versionID3 =versionHigh+ "." + mp3Stream.ReadByte();
//------------------------------------------------------------------------- ---
//D?tection de certains flags (A COMPLETER)
this.ID3Flags = ProcessID3Flags( (byte) mp3Stream.ReadByte() );
//----------------------------------------------------------------------------
// On extrait la taille du tag ID3
int tagSize = ReadSyncsafeInteger(mp3Stream);
//System.err.println("TagSize: "+tagSize);
// ------------------NEWNEWNWENENEWNENWEWN-------------------------------
//Fill a byte buffer, then process according to correct version
b = new byte[tagSize+2];
mp3Stream.Read(b, 0, b.Length);
ByteBuffer bb = new ByteBuffer(b);
if (ID3Flags[0]==true) {
//We have unsynchronization, first re-synchronize
bb = synchronizer.synchronize(bb);
}
if(versionHigh == "2") {
tag = v23.Read(bb, ID3Flags, Id3v2Tag.ID3V22);
}
else if(versionHigh == "3") {
tag = v23.Read(bb, ID3Flags, Id3v2Tag.ID3V23);
}
else if(versionHigh == "4") {
throw new CannotReadException("ID3v2 tag version "+ versionID3 + " not supported !");
}
else {
throw new CannotReadException("ID3v2 tag version "+ versionID3 + " not supported !");
}
return tag;
}
public bool IsResourceEncrypted(Stream resourceStream)
{
long currentPosition = resourceStream.Position;
resourceStream.Seek(0, SeekOrigin.Begin);
var buffer = new byte[EncryptionSize];
resourceStream.Read(buffer, 0, EncryptionSize);
resourceStream.Seek(currentPosition, SeekOrigin.Begin);
return (buffer[0] == EncryptionFlag && buffer[1] == EncryptionFlag);
}
public EncodingInfo Read( Stream raf )
{
EncodingInfo info = new EncodingInfo();
//Begin info fetch-------------------------------------------
if ( raf.Length==0 ) {
//Empty File
throw new CannotReadException("File is empty");
}
raf.Seek( 0 , SeekOrigin.Begin);
//MP+ Header string
byte[] b = new byte[3];
raf.Read(b, 0, b.Length);
string mpc = new string(System.Text.Encoding.ASCII.GetChars(b));
if (mpc != "MP+" && mpc == "ID3") {
//TODO Do we have to do this ??
//we have an ID3v2 tag at the beginning
//We quickly jump to MPC data
raf.Seek(6, SeekOrigin.Begin);
int tagSize = ReadSyncsafeInteger(raf);
raf.Seek(tagSize+10, SeekOrigin.Begin);
//retry to read MPC stream
b = new byte[3];
raf.Read(b, 0, b.Length);
mpc = new string(System.Text.Encoding.ASCII.GetChars(b));
if (mpc != "MP+") {
//We could definitely not go there
throw new CannotReadException("MP+ Header not found");
}
} else if (mpc != "MP+"){
throw new CannotReadException("MP+ Header not found");
}
b = new byte[25];
raf.Read(b, 0, b.Length);
MpcHeader mpcH = new MpcHeader(b);
//We only support v7 Stream format, so if it isn't v7, then returned values
//will be bogus, and the file will be ignored
double pcm = mpcH.SamplesNumber;
info.Length = (int) ( pcm * 1152 / mpcH.SamplingRate );
info.ChannelNumber = mpcH.ChannelNumber;
info.SamplingRate = mpcH.SamplingRate;
info.EncodingType = mpcH.EncodingType;
info.ExtraEncodingInfos = mpcH.EncoderInfo;
info.Bitrate = ComputeBitrate( info.Length, raf.Length );
return info;
}
public EncodingInfo Read(Stream raf)
{
//Read the infos--------------------------------------------------------
if (raf.Length == 0) {
//Empty File
throw new CannotReadException("Error: File empty");
}
raf.Seek(0, SeekOrigin.Begin);
//FLAC Header string
byte[] b = new byte[4];
raf.Read(b, 0, b.Length);
string flac = new string(System.Text.Encoding.ASCII.GetChars(b));
if (flac != "fLaC") {
throw new CannotReadException("fLaC Header not found");
}
MetadataBlockDataStreamInfo mbdsi = null;
bool isLastBlock = false;
while (!isLastBlock) {
b = new byte[4];
raf.Read(b, 0, b.Length);
MetadataBlockHeader mbh = new MetadataBlockHeader(b);
if (mbh.BlockType == (int) MetadataBlockHeader.BlockTypes.StreamInfo) {
b = new byte[mbh.DataLength];
raf.Read(b, 0, b.Length);
mbdsi = new MetadataBlockDataStreamInfo(b);
if (!mbdsi.Valid) {
throw new CannotReadException("FLAC StreamInfo not valid");
}
break;
}
raf.Seek(raf.Position + mbh.DataLength, SeekOrigin.Begin);
isLastBlock = mbh.IsLastBlock;
mbh = null; //Free memory
}
EncodingInfo info = new EncodingInfo();
info.Length = mbdsi.Length;
info.ChannelNumber = mbdsi.ChannelNumber;
info.SamplingRate = mbdsi.SamplingRate;
info.EncodingType = mbdsi.EncodingType;
info.ExtraEncodingInfos = "";
info.Bitrate = ComputeBitrate(mbdsi.Length, raf.Length);
return info;
}
public Id3v1Tag Read( Stream mp3Stream )
{
Id3v1Tag tag = new Id3v1Tag();
//Check wether the file contains an Id3v1 tag--------------------------------
mp3Stream.Seek( -128 , SeekOrigin.End);
byte[] b = new byte[3];
mp3Stream.Read( b, 0, 3 );
mp3Stream.Seek(0, SeekOrigin.Begin);
string tagS = new string(System.Text.Encoding.ASCII.GetChars( b ));
if(tagS != "TAG"){
throw new CannotReadException("There is no Id3v1 Tag in this file");
}
mp3Stream.Seek( - 128 + 3, SeekOrigin.End );
//Parse the tag -)------------------------------------------------
string songName = Read(mp3Stream, 30);
//------------------------------------------------
string artist = Read(mp3Stream, 30);
//------------------------------------------------
string album = Read(mp3Stream, 30);
//------------------------------------------------
string year = Read(mp3Stream, 4);
//------------------------------------------------
string comment = Read(mp3Stream, 30);
//------------------------------------------------
string trackNumber = "";
mp3Stream.Seek(- 2, SeekOrigin.Current);
b = new byte[2];
mp3Stream.Read(b, 0, 2);
if ( b[0] == 0 ) {
trackNumber = b[1].ToString ();
}
//------------------------------------------------
byte genreByte = (byte) mp3Stream.ReadByte();
mp3Stream.Seek(0, SeekOrigin.Begin);
tag.SetTitle( songName );
tag.SetArtist( artist );
tag.SetAlbum( album );
tag.SetYear( year );
tag.SetComment( comment );
tag.SetTrack( trackNumber );
tag.SetGenre( tag.TranslateGenre(genreByte) );
return tag;
}
public override object Deserialize(Stream inputStream)
{
var sr = new StreamReader(inputStream);
inputStream.Seek(0, SeekOrigin.Begin);
var serialized = sr.ReadToEnd();
return _serializer.Deserialize(serialized, _primaryType);
}
/// <summary>
/// Reads stream to match it against a dictionary of all known units for an ingredient
/// </summary>
/// <param name="stream"></param>
/// <param name="matchdata"></param>
/// <returns></returns>
public bool Read(Stream stream, MatchData matchdata)
{
if (data == null)
{
data = new NumericVocab();
}
var matchFound = false;
var buffer = string.Empty;
var matchPos = stream.Position;
int curByte;
while ((curByte = stream.ReadByte()) >= 0)
{
buffer += (char)curByte;
NumericNode node;
var match = data.Parse(buffer, out node);
if (match == MatchPrecision.None)
{
stream.Seek(matchPos, SeekOrigin.Begin);
break;
}
if (match == MatchPrecision.Exact)
{
matchPos = stream.Position;
matchFound = true;
matchdata.Amount = new Amount { SizeHigh = node.Value };
}
}
return matchFound;
}
public override object Deserialize(Stream inputStream)
{
inputStream.Seek(0, SeekOrigin.Begin);
return JSON.Deserialize(new StreamReader(inputStream), _primaryType,
new Options(
unspecifiedDateTimeKindBehavior: UnspecifiedDateTimeKindBehavior.IsUTC));
}
public WebImage(Stream imageStream) {
if (imageStream.CanSeek) {
imageStream.Seek(0, SeekOrigin.Begin);
_content = new byte[imageStream.Length];
using (BinaryReader reader = new BinaryReader(imageStream)) {
reader.Read(_content, 0, (int)imageStream.Length);
}
}
else {
List<byte[]> chunks = new List<byte[]>();
int totalSize = 0;
using (BinaryReader reader = new BinaryReader(imageStream)) {
// Pick some size for chunks that is still under limit
// that causes them to be placed on the large object heap.
int chunkSizeInBytes = 1024 * 50;
byte[] nextChunk = null;
do {
nextChunk = reader.ReadBytes(chunkSizeInBytes);
totalSize += nextChunk.Length;
chunks.Add(nextChunk);
}
while (nextChunk.Length == chunkSizeInBytes);
}
_content = new byte[totalSize];
int startIndex = 0;
foreach (var chunk in chunks) {
chunk.CopyTo(_content, startIndex);
startIndex += chunk.Length;
}
}
_initialFormat = ValidateImageContent(_content, "imageStream");
_currentFormat = _initialFormat;
}
public D900CdrElement DecodeRecord(Stream asnStream, bool skipFillers)
{
TlvObject tlv;
long offset = asnStream.Position;
// Verify that the next byte - Billing Record Tag (0xE1)
if (!skipFillers)
{
int b = asnStream.ReadByte();
if (b != 0xE1)
{
return null;
}
asnStream.Seek(-1, SeekOrigin.Current);
}
BerDecoderResult pr = DecodeTlv(asnStream, out tlv, ref offset, 0, byte.MaxValue);
D900CdrElement record = null;
if (pr == BerDecoderResult.Finished)
{
record = _tlvParser.ParseTlvObject(tlv); ;
}
return record;
}
public void Save(Stream output)
{
BinaryWriter writer = new BinaryWriter(output);
writer.Write(this.version);
writer.Write((uint)0);
writer.Write((uint)0);
writer.Write(this.localeHash);
writer.Write(this.blendLinks.Count);
for (int i = 0; i < this.blendLinks.Count; i++)
{
writer.Write(i);
}
writer.Write(this.bidirectional);
writer.Write(this.casPanelGroup);
writer.Write(this.casPanelSubGroup);
writer.Write((uint)0);
uint tgiOffset = (uint)output.Position - 8;
this.keytable.size = 4;
writer.Write(this.blendLinks.Count);
for (int i = 0; i < blendLinks.Count; i++)
{
this.blendLinks[i].Save(output);
this.keytable.size += 16;
}
// Seek back to byte 4 to output the keytable length and size
output.Seek(4, SeekOrigin.Begin);
writer.Write(tgiOffset);
writer.Write(this.keytable.size);
}
public void Import(object importSettingsViewModel, Stream stream, CogProject project)
{
XDocument doc;
if (ZipFile.IsZipFile(stream, false))
{
stream.Seek(0, SeekOrigin.Begin);
ZipFile zipFile = ZipFile.Read(stream);
ZipEntry kmlEntry = zipFile.First(entry => entry.FileName.EndsWith(".kml"));
doc = XDocument.Load(kmlEntry.OpenReader(), LoadOptions.SetLineInfo);
}
else
{
doc = XDocument.Load(stream, LoadOptions.SetLineInfo);
}
XElement root = doc.Root;
Debug.Assert(root != null);
if (root.GetDefaultNamespace() != DefaultNamespace)
throw new ImportException("The specified file is not a KML file.");
XElement document = root.Element(Kml + "Document");
if (document == null)
throw new ImportException("Missing Document element.");
var regions = new Dictionary<Variety, List<GeographicRegion>>();
LoadFolder(project, regions, document);
foreach (KeyValuePair<Variety, List<GeographicRegion>> varietyRegions in regions)
varietyRegions.Key.Regions.AddRange(varietyRegions.Value);
}
public override object Deserialize(Stream inputStream)
{
var sr = new StreamReader(inputStream);
inputStream.Seek(0, SeekOrigin.Begin);
var serialized = sr.ReadToEnd();
return JSON.ToObject(serialized);
}
/// <summary>
/// Checks that the actual stream has the same content as another one.
/// </summary>
/// <param name="check">The fluent check to be extended.</param>
/// <param name="expected">The stream to compare content with.</param>
/// <returns>A check link</returns>
public static ICheckLink<ICheck<Stream>> HasSameSequenceOfBytesAs(this ICheck<Stream> check, Stream expected)
{
var checker = ExtensibilityHelper.ExtractChecker(check);
var value = checker.Value;
return checker.ExecuteCheck(
() =>
{
if (value.Length != expected.Length)
{
var message = GenerateMessageWhenFullyDistinct(expected, checker, value);
throw new FluentCheckException(message.ToString());
}
// Keeps initial positions to be able to restore them after the check
var valueInitialPosition = value.Position;
var otherInitialPosition = expected.Position;
value.Seek(0, SeekOrigin.Begin);
expected.Seek(0, SeekOrigin.Begin);
while (value.Position < value.Length)
{
if (value.ReadByte() != expected.ReadByte())
{
var message = GenerateMessageWhenSameLenghtButDiffContent(expected, checker, value);
throw new FluentCheckException(message.ToString());
}
}
// Side-effect free. Restore initial positions of streams
value.Position = valueInitialPosition;
expected.Position = otherInitialPosition;
},
BuildNegatedMessage(expected, value).ToString());
}
public static string StreamToString(Stream stream)
{
stream.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(stream);
return reader.ReadToEnd();
}
/// <summary>
/// 压缩流数据
/// </summary>
/// <param name="aSourceStream"></param>
/// <returns></returns>
public static byte[] EnCompress(Stream aSourceStream)
{
MemoryStream vMemory = new MemoryStream();
aSourceStream.Seek(0, SeekOrigin.Begin);
vMemory.Seek(0, SeekOrigin.Begin);
try
{
using (GZipStream vZipStream = new GZipStream(vMemory, CompressionMode.Compress))
{
byte[] vFileByte = new byte[1024];
int vRedLen = 0;
do
{
vRedLen = aSourceStream.Read(vFileByte, 0, vFileByte.Length);
vZipStream.Write(vFileByte, 0, vRedLen);
}
while (vRedLen > 0);
}
}
finally
{
vMemory.Dispose();
}
return vMemory.ToArray();
}
public void ExportTo(IntelHexFile HexFile, Stream DestinationStream)
{
bool first = true;
uint offset = 0;
uint address = 0;
foreach (IntelHexLine line in HexFile)
{
if (line is IntelHexDataLine)
{
var dataLine = (IntelHexDataLine)line;
if (_trimStart && first)
offset = address + dataLine.Address;
first = false;
DestinationStream.Seek(address + dataLine.Address - offset, SeekOrigin.Begin);
dataLine.Data.Seek(0, SeekOrigin.Begin);
dataLine.Data.CopyTo(DestinationStream);
}
if (line is IntelHexExAddressLine)
{
var addresLine = (IntelHexExAddressLine)line;
address = (uint)(addresLine.AddressExtension << 16);
}
if (line is IntelHexSegAddressLine)
{
var addresLine = (IntelHexSegAddressLine)line;
address = addresLine.SegmentAddress;
}
}
}
public byte[] ComputeHash(Stream stream)
{
stream.Seek(0, SeekOrigin.Begin);
var computeHash = hashAlgorithm.ComputeHash(stream);
return computeHash;
}
