/// <summary>
/// ThumbsFile をファイルから読み込みます。
/// 指定したファイルが存在しない場合は新しくファイルを作成します。
/// </summary>
/// <param name="filename">ファイル名を指定します。</param>
/// <returns>作成した ThumbsFile のインスタンスを返します。</returns>
public static ThumbsFile OpenFile(string filename)
{
ThumbsFile thumbsfile;
if (System.IO.File.Exists(filename))
{
StreamAccessor accessor = new StreamAccessor(System.IO.File.OpenRead(filename));
thumbsfile = accessor.Read <ThumbsFile>();
accessor.Stream.Close();
}
else if (System.IO.Path.GetExtension(filename).ToLower() != ".thm" && System.IO.File.Exists(filename + ".thm"))
{
filename += ".thm";
StreamAccessor accessor = new StreamAccessor(System.IO.File.OpenRead(filename));
thumbsfile = accessor.Read <ThumbsFile>();
accessor.Stream.Close();
}
else
{
thumbsfile = new ThumbsFile();
thumbsfile.dirs = new DirectoryCollection(thumbsfile);
thumbsfile.thumbs = new ImageCollection(thumbsfile);
}
thumbsfile.filename = filename;
return(thumbsfile);
}
public void SaveFile(string filePath)
{
using (var accessor = new StreamAccessor(new FileStream(filePath, FileMode.Create, FileAccess.Write)))
{
Save(accessor, Path.GetDirectoryName(filePath));
}
}
private static void Verify1(string tempFile, SerializationEngine serializer, IReadOnlyList <TestClass> list)
{
using (var stream = new FileStream(tempFile, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
var data = new StreamAccessor(stream);
var lFile = new LowLevelAppendOnlyFile(data);
var file = new GenericAppendOnlyFile <TestClass>(lFile, serializer);
var records = file.ReadFrom(0).ToList();
// fails without sorting the lists, so the ordering is somehow incorrect
//list = list.OrderBy(it => it.Name).ToList();
//records = records.OrderBy(it => it.Name).ToList();
// verify that the index is built correctly
for (var i = 0; i < COUNT; i++)
{
var r = records[i];
if (r.Name != list[i].Name)
{
throw new Exception($"Verify1: Expected [{list[i].Name}] but was [{r.Name}].");
}
if (r.Address != list[i].Address)
{
throw new Exception($"Verify1: Expected [{list[i].Address}] but was [{r.Address}].");
}
}
}
}
private static new RiffFile read(StreamAccessor accessor)
{
if ("RIFF" != accessor.ReadString(EncodingType.CC4))
{
throw new System.ApplicationException("指定したデータは RIFF データではありません。");
}
RiffFile ret = new RiffFile();
uint size = accessor.ReadUInt32(EncodingType.U4);
ret.type = accessor.ReadString(EncodingType.CC4);
ret.chunks = new Gen::List <Chunk>();
StreamAccessor acChunks = new StreamAccessor(accessor.ReadSubStream(size - 4));
try{
while (acChunks.RestLength > 0)
{
ret.chunks.Add(acChunks.Read <Chunk>());
}
}finally{
acChunks.Stream.Close();
}
return(ret);
}
public void SaveToFile(string filePath)
{
using (var accessor = new StreamAccessor(new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite)))
{
Save(accessor);
}
}
//=================================================
// 他
//=================================================
/// <summary>
/// ファイルを保存します。
/// </summary>
public void Save()
{
StreamAccessor accessor = new StreamAccessor(System.IO.File.OpenWrite(this.filename));
accessor.Write(this);
accessor.Stream.Close();
}
private static void Generate(string tempFile, SerializationEngine serializer, List <TestClass> list,
Action <Action <int> > loop)
{
using (var stream = new FileStream(tempFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
var data = new StreamAccessor(stream);
var lFile = new LowLevelAppendOnlyFile(data);
var file = new GenericAppendOnlyFile <TestClass>(lFile, serializer);
// append COUNT records
ShowTime("append", () => loop(i => file.Append(list[i])));
// read all the records
ShowTime("read all", () => { var records = file.ReadFrom(0).ToList(); });
// read all the records, one at a time
ShowTime("read all, one at a time", () => loop(i => file.Read(i)));
}
// close and reopen the file (rebuilds the index)
ShowTime("rebuild index", () =>
{
using (var stream = new FileStream(tempFile, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
var data = new StreamAccessor(stream);
var lFile = new LowLevelAppendOnlyFile(data);
}
});
}
private static void write(Chunk chunk, StreamAccessor accessor)
{
accessor.Write(chunk.name, EncodingType.CC4);
StreamAccessor ac2 = new StreamAccessor(accessor.WriteSubStream(4));
long pos0 = accessor.Position;
// 内容
if (chunk.content != null)
{
if (chunk.content is byte[])
{
accessor.Write((byte[])chunk.content);
}
else if (chunk.content is System.IO.Stream)
{
accessor.WriteStream((System.IO.Stream)chunk.content);
}
else
{
RiffChunkReadWriteAttribute.Write(chunk.content, accessor);
}
}
else if (chunk._data != null)
{
accessor.Write(chunk._data);
}
else if (chunk._stream != null)
{
accessor.WriteStream(chunk.Stream);
}
ac2.Write(checked ((uint)(accessor.Position - pos0)), EncodingType.U4);
ac2.Stream.Close();
}
public void GenericAppendOnlyFileSmokeTest()
{
var stream = new MemoryStream();
var data = new StreamAccessor(stream);
var file = new LowLevelAppendOnlyFile(data);
var serializer = new ProtoBufSerializationEngine();
var sut = new GenericAppendOnlyFile <TestClass>(file, serializer);
sut.Append(new TestClass {
Name = "Marcel", Address = "Kennesaw, GA"
});
sut.Append(new TestClass {
Name = "Gigi Meseriasu", Address = "Washington, DC"
});
var r1 = sut.Read(0);
Assert.AreEqual("Marcel", r1.Name);
Assert.AreEqual("Kennesaw, GA", r1.Address);
var rs = sut.ReadFrom(0).ToList();
var r2 = rs[1];
Assert.AreEqual("Gigi Meseriasu", r2.Name);
Assert.AreEqual("Washington, DC", r2.Address);
Assert.AreEqual(2, sut.Index.Length);
Assert.AreEqual(0, sut.Index[0]);
}
public static ThumbsFile read(StreamAccessor accessor)
{
ThumbsFile r = new ThumbsFile();
Riff::RiffFile riff = Riff::RiffFile.FromStream(accessor.Stream, true);
StreamAccessor ac;
foreach (Riff::Chunk chunk in riff.EnumerateChunksByName("head"))
{
ac = new StreamAccessor(chunk.Stream);
if (VERSION != ac.ReadInt32(EncodingType.I4))
{
throw new System.ApplicationException("ファイルフォーマットの version が異なります。");
}
break;
}
foreach (Riff::Chunk chunk in riff.EnumerateChunksByName("thms"))
{
r.thumbs = chunk.GetContent <ImageCollection>();
break;
}
foreach (Riff::Chunk chunk in riff.EnumerateChunksByName("dirs"))
{
ac = new StreamAccessor(chunk.Stream);
r.dirs = ac.Read <DirectoryCollection>();
break;
}
riff.Close();
r.read_initialize();
return(r);
}
internal static List read(StreamAccessor accessor)
{
List ret = new List();
if ("LIST" != accessor.ReadString(EncodingType.CC4))
{
throw new System.ApplicationException("読み込もうとしているデータは LIST チャンクではないです。");
}
uint size = accessor.ReadUInt32(EncodingType.U4);
ret.type = accessor.ReadString(EncodingType.CC4);
ret.chunks = new Gen::List <Chunk>();
StreamAccessor acChunks = new StreamAccessor(accessor.ReadSubStream(size - 4));
try{
while (acChunks.RestLength > 0)
{
ret.chunks.Add(acChunks.Read <Chunk>());
}
}finally{
acChunks.Stream.Close();
}
return(ret);
}
private int ReadTagHeader(StreamAccessor accessor, out bool unsync)
{
const string DIFF_VERSION = @"読み込もうとしている ID3 タグの版は 2.{0}.{1}です。
この関数では 2.3.0 の読み取りにしか対応していません。";
//-------------------------------------------------------
if (accessor.ReadString(EncodingType.CC3) != "ID3")
{
throw new FileFormatException("読み込もうとしているバイナリストリームは ID3 タグではありません。");
}
byte minor = accessor.ReadByte(EncodingType.U1);
byte revision = accessor.ReadByte(EncodingType.U1);
if (minor != 3 || revision != 0)
{
throw new FileFormatException(string.Format(DIFF_VERSION, minor, revision));
}
byte flags = accessor.ReadByte(EncodingType.U1);
unsync = (flags & 0x80) != 0;
this.has_ext = (flags & 0x40) != 0;
this.experimental = (flags & 0x20) != 0;
return(accessor.ReadInt32(EncodingType.Int28BE));
}
private void WriteTagHeader(StreamAccessor accessor, bool unsync, out long pos_size)
{
accessor.Write("ID3", EncodingType.F4BE);
accessor.Write((byte)3, EncodingType.U1);
accessor.Write((byte)0, EncodingType.U1);
byte num = 0;
if (unsync)
{
num = (byte)(num | 0x80);
}
if (this.has_ext)
{
num = (byte)(num | 0x40);
}
if (this.experimental)
{
num = (byte)(num | 0x20);
}
accessor.Write(num, EncodingType.U1);
pos_size = accessor.Position;
accessor.Skip(4L);
}
private static void write_chunk(ImageCollection images, StreamAccessor accessor)
{
accessor.Write(images.count, EncodingType.I4);
foreach (Thumb thm in images.sorted)
{
accessor.Write(thm);
}
}
protected override void Write(FileDataCached value, StreamAccessor accessor)
{
// Update
if (value.changed)
{
if (value.stream != null)
value.stream.Close(); }
value.stream = new System.IO.MemoryStream();
value.Write(new StreamAccessor(value.stream));
}
internal static void Write(object value, StreamAccessor accessor)
{
System.Type type = value.GetType();
RiffChunkReadWriteAttribute attr = GetAttribute(type);
const System.Reflection.BindingFlags BF = System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic;
System.Reflection.MethodInfo m = type.GetMethod(attr.write, BF, null, new System.Type[] { type, typeof(StreamAccessor) }, read_mods);
m.Invoke(null, new object[] { value, accessor });
}
public void Write(StreamAccessor accessor)
{
this.written = true;
accessor.WriteAs <RiffFile>(this.file);
foreach (System.IO.Stream stream in this.streams)
{
stream.Close();
}
}
private static void write(DirectoryCollection dirs, StreamAccessor accessor)
{
StreamAccessor acSize = new StreamAccessor(accessor.WriteSubStream(4));
long pos0 = accessor.Position;
foreach (ImageDirectory childdir in dirs)
{
accessor.Write(childdir);
}
acSize.Write(checked ((uint)(accessor.Position - pos0)), EncodingType.U4);
acSize.Stream.Close();
}
private static void write(ImageDirectory dir, StreamAccessor accessor)
{
accessor.Write(dir.name, EncodingType.NoSpecified);
accessor.Write((uint)dir.images.Count, EncodingType.U4);
foreach (int index in dir.images)
{
accessor.Write(index, EncodingType.I4);
}
accessor.Write(dir.dirs);
}
internal void Load(BuildModule module)
{
if (_module != null)
{
throw new InvalidOperationException();
}
_module = module;
if (_isNew)
{
if (_bufferLength == 0)
{
var image = _module.Image;
_moduleTableOffset = BuildAssembly.RowSize * image.GetAssemblyCount();
_typeTableOffset = _moduleTableOffset + BuildModule.RowSize;
_methodTableOffset = _typeTableOffset + (BuildType.RowSize * image.GetTypeDefCount());
_fieldTableOffset = _methodTableOffset + (BuildMethod.RowSize * image.GetMethodCount());
_propertyTableOffset = _fieldTableOffset + (BuildField.RowSize * image.GetFieldCount());
_eventTableOffset = _propertyTableOffset + (BuildProperty.RowSize * image.GetPropertyCount());
_resourceTableOffset = _eventTableOffset + (BuildEvent.RowSize * image.GetEventCount());
_bufferLength = _resourceTableOffset + (BuildResource.RowSize * image.GetManifestResourceCount());
}
_buffer = new byte[_bufferLength];
_blobs = new BlobList();
_strings = new StringSerializer();
_signatures = new SignatureList(_strings);
_objects = new ModuleObjectState(this);
}
else
{
using (var accessor = new StreamAccessor(new FileStream(_stateFilePath, FileMode.Open, FileAccess.Read, FileShare.None)))
{
_bufferLength = accessor.Read7BitEncodedInt();
_buffer = accessor.ReadBytes(_bufferLength);
_objects = new ModuleObjectState(this, accessor);
_blobs = new BlobList(accessor);
var stringBlob = new Blob(accessor.ReadBytes(accessor.Read7BitEncodedInt()));
StrongCryptoUtils.Decrypt(stringBlob.GetBuffer(), 0, stringBlob.Length);
_strings = new StringSerializer(new BlobAccessor(stringBlob));
_signatures = new SignatureList(accessor, _strings);
}
}
_strings.DelayWrite = true;
_signatures.DelayWrite = true;
}
public static unsafe void WriteToStream(Tag tag, StreamAccessor accessor)
{
tag.Encode();
byte[] buffer = new byte[0x80];
fixed(byte *data = buffer)
{
tagID3v1_1 *pDst = (tagID3v1_1 *)data;
*pDst = tag.data;
}
accessor.Write(buffer);
}
internal void Serialize(StreamAccessor accessor)
{
var bufferBlob = new Blob();
var bufferAccessor = new BlobAccessor(bufferBlob);
accessor.Write7BitEncodedInt(_count);
var entries = new Entry[_count];
for (int i = 0; i < _count; i++)
{
int offset = (int)bufferAccessor.Position;
var item = _items[i];
if (item != null && item.IsChanged)
{
item.Write(bufferAccessor);
}
else if (_entries != null && _entries.Length > i)
{
int existingSize = _entries[i].Size;
if (existingSize > 0)
{
bufferAccessor.Write(_buffer, _entries[i].Offset, existingSize);
}
}
int size = (int)bufferAccessor.Position - offset;
accessor.Write7BitEncodedInt(offset);
accessor.Write7BitEncodedInt(size);
entries[i] =
new Entry()
{
Offset = offset,
Size = size,
};
}
_entries = entries;
_buffer = bufferBlob.ToArray();
Array.Clear(_items, 0, _count);
accessor.Write7BitEncodedInt(_buffer.Length);
if (_buffer.Length > 0)
{
accessor.Write(_buffer, 0, _buffer.Length);
}
}
private static ImageDirectory read(StreamAccessor accessor)
{
ImageDirectory dir = new ImageDirectory(accessor.ReadString(EncodingType.NoSpecified));
uint count = accessor.ReadUInt32(EncodingType.U4);
for (int i = 0; i < count; i++)
{
dir.images.Add(accessor.ReadInt32(EncodingType.I4));
}
dir.dirs = accessor.Read <DirectoryCollection>();
return(dir);
}
internal void Save()
{
if (!_isChanged && !_isNew)
{
return;
}
if (_isNew)
{
// Set paths
string fileName = _module.NameChanged ? _module.NewName : _module.Name;
var assembly = (BuildAssembly)_module.Assembly;
string outputPath = assembly.OutputPath;
if (outputPath == null)
{
outputPath = Path.GetDirectoryName(assembly.Location);
}
_outputFilePath = Path.Combine(outputPath, fileName);
_stateFilePath = _outputFilePath + ".adstate";
_buildFilePath = _outputFilePath + ".adbuild";
}
using (var accessor = new StreamAccessor(new FileStream(_stateFilePath, FileMode.Create, FileAccess.Write, FileShare.None)))
{
accessor.Write7BitEncodedInt(_bufferLength);
accessor.Write(_buffer, 0, _bufferLength);
_objects.Serialize(accessor);
_blobs.Serialize(accessor);
var signatureBlob = new Blob();
_signatures.Serialize(new BlobAccessor(signatureBlob));
var stringBlob = new Blob();
_strings.Serialize(new BlobAccessor(stringBlob));
StrongCryptoUtils.Encrypt(stringBlob.GetBuffer(), 0, stringBlob.Length);
accessor.Write7BitEncodedInt(stringBlob.Length);
accessor.Write(stringBlob.GetBuffer(), 0, stringBlob.Length);
accessor.Write(signatureBlob.GetBuffer(), 0, signatureBlob.Length);
}
_isNew = false;
_isChanged = false;
}
private void WriteExtHeader(StreamAccessor accessor, out StreamAccessor str_crc32)
{
accessor.Write(this.hascrc ? 10 : 6, EncodingType.U4BE);
ushort num = this.hascrc ? ((ushort)0x8000) : ((ushort)0);
accessor.Write(num, EncodingType.U2BE);
accessor.Write((uint)0, EncodingType.U4BE);
if (this.hascrc)
{
str_crc32 = new StreamAccessor(accessor.WriteSubStream(4L));
}
else
{
str_crc32 = null;
}
}
internal static object Read(System.Type type, StreamAccessor accessor)
{
RiffChunkReadWriteAttribute attr = GetAttribute(type);
const System.Reflection.BindingFlags BF = System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic;
System.Reflection.MethodInfo m = type.GetMethod(attr.read, BF, null, read_types, read_mods);
object ret = m.Invoke(null, new object[] { accessor });
if (ret == null)
{
throw new System.ApplicationException("RIFF Chunk 読込の為に呼び出したメソッドの返値が null です。");
}
return(ret);
}
private static ImageCollection read_chunk(StreamAccessor accessor)
{
int c = accessor.ReadInt32(EncodingType.I4);
ImageCollection ret = new ImageCollection(c);
ret.count = c;
try{
while (accessor.RestLength > 0)
{
ret.register(accessor.Read <Thumb>());
}
}catch (System.Exception e) {
afh.File.__dll__.log.WriteError(e, "ImageCollection 読み取り中のエラー");
}
return(ret);
}
internal unsafe Tag(StreamAccessor accessor, System.Text.Encoding enc)
{
this.changed = false;
byte[] buffer = new byte[tagID3v1_1.SIZE];
if (tagID3v1_1.SIZE != accessor.Stream.Read(buffer, 0, tagID3v1_1.SIZE))
{
throw new FileFormatException("Stream の長さが ID3v1 のタグを格納できる大きさになっていません。");
}
fixed(byte *pData = buffer)
{
this.data = *(tagID3v1_1 *)pData;
}
this.Decode(enc);
}
public void AddChunk(string name, out StreamAccessor ac_chunk)
{
if (written)
{
throw new System.ObjectDisposedException("this", ERR_WRITTEN);
}
Chunk chunk = new Chunk(name);
this.file.Chunks.Add(chunk);
System.IO.MemoryStream str = new System.IO.MemoryStream();
chunk.Stream = str;
this.streams.Add(str);
ac_chunk = new StreamAccessor(str);
}
public static unsafe void WritePEChecksum(string filePath, uint checkSum)
{
using (var accessor = new StreamAccessor(new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite)))
{
// DOS
DOSHeader dosHeader;
fixed(byte *pBuff = accessor.ReadBytes(PEConstants.DosHeaderSize))
{
dosHeader = *(DOSHeader *)pBuff;
}
if (dosHeader.Signature != PEConstants.DosSignature)
{
throw new BadImageFormatException(SR.DOSHeaderSignatureNotValid);
}
accessor.Position = dosHeader.Lfanew;
// NT Signature
if (accessor.ReadUInt32() != PEConstants.NTSignature)
{
throw new BadImageFormatException(SR.PESignatureNotValid);
}
// COFF
accessor.ReadBytes(PEConstants.COFFHeaderSize);
// PE
ushort peMagic = accessor.ReadUInt16();
if (peMagic == PEConstants.PEMagic32)
{
accessor.ReadBytes(62);
}
else if (peMagic == 0x20b)
{
accessor.ReadBytes(62);
}
else
{
throw new BadImageFormatException(SR.PEHeaderSignatureNotValid);
}
accessor.Write((uint)checkSum);
}
}
