internal void BeginGetHash(TorrentManager manager, int pieceIndex, MainLoopResult callback)
{
int count = 0;
long offset = (long)manager.Torrent.PieceLength * pieceIndex;
long endOffset = Math.Min(offset + manager.Torrent.PieceLength, manager.Torrent.Size);
byte[] hashBuffer = BufferManager.EmptyBuffer;
ClientEngine.BufferManager.GetBuffer(ref hashBuffer, Piece.BlockSize);
#if NETSTANDARD1_5
SHA1 hasher = SHA1.Create();
#else
SHA1 hasher = HashAlgoFactory.Create <SHA1>();
#endif
hasher.Initialize();
DiskIOCallback readCallback = null;
readCallback = delegate(bool successful) {
if (successful)
{
#if NETSTANDARD1_5
var h = hasher.ComputeHash(hashBuffer, 0, count);
h.CopyTo(hashBuffer, 0);
#else
hasher.TransformBlock(hashBuffer, 0, count, hashBuffer, 0);
#endif
}
offset += count;
if (!successful || offset == endOffset)
{
object hash = null;
if (successful)
{
#if NETSTANDARD1_5
hash = hasher.ComputeHash(hashBuffer, 0, 0);
#else
hasher.TransformFinalBlock(hashBuffer, 0, 0);
hash = hasher.Hash;
#endif
}
((IDisposable)hasher).Dispose();
ClientEngine.BufferManager.FreeBuffer(ref hashBuffer);
ClientEngine.MainLoop.Queue(delegate {
callback(hash);
});
}
else
{
count = (int)Math.Min(Piece.BlockSize, endOffset - offset);
QueueRead(manager, offset, hashBuffer, count, readCallback);
}
};
count = (int)Math.Min(Piece.BlockSize, endOffset - offset);
QueueRead(manager, offset, hashBuffer, count, readCallback);
}
public void Initialise(TorrentManager manager, byte[] buffer, long offset, int count, int pieceLength, IList <TorrentFile> files)
{
this.actualCount = 0;
this.buffer = buffer;
this.callback = null;
this.complete = false;
this.count = count;
this.files = files;
this.manager = manager;
this.offset = offset;
this.peerId = null;
this.pieceLength = pieceLength;
}
internal void BeginGetHash(TorrentManager manager, int pieceIndex, MainLoopResult callback)
{
var count = 0;
var offset = (long)manager.Torrent.PieceLength * pieceIndex;
var endOffset = Math.Min(offset + manager.Torrent.PieceLength, manager.Torrent.Size);
var hashBuffer = BufferManager.EmptyBuffer;
ClientEngine.BufferManager.GetBuffer(ref hashBuffer, Piece.BlockSize);
var hasher = HashAlgoFactory.Create <SHA1>();
hasher.Initialize();
DiskIOCallback readCallback = null;
readCallback = successful =>
{
if (successful)
{
hasher.TransformBlock(hashBuffer, 0, count, hashBuffer, 0);
}
offset += count;
if (!successful || offset == endOffset)
{
object hash = null;
if (successful)
{
hasher.TransformFinalBlock(hashBuffer, 0, 0);
hash = hasher.Hash;
}
((IDisposable)hasher).Dispose();
ClientEngine.BufferManager.FreeBuffer(ref hashBuffer);
ClientEngine.MainLoop.Queue(() => callback(hash));
}
else
{
count = (int)Math.Min(Piece.BlockSize, endOffset - offset);
QueueRead(manager, offset, hashBuffer, count, readCallback);
}
};
count = (int)Math.Min(Piece.BlockSize, endOffset - offset);
QueueRead(manager, offset, hashBuffer, count, readCallback);
}
internal void BeginGetHash(TorrentManager manager, int pieceIndex, MainLoopResult callback)
{
var count = 0;
var offset = (long)manager.Torrent.PieceLength * pieceIndex;
var endOffset = Math.Min(offset + manager.Torrent.PieceLength, manager.Torrent.Size);
var hashBuffer = BufferManager.EmptyBuffer;
ClientEngine.BufferManager.GetBuffer(ref hashBuffer, Piece.BlockSize);
var hashProvider = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1);
var hasher = hashProvider.CreateHash();
DiskIOCallback readCallback = null;
readCallback = delegate(bool successful)
{
// TODO [uwp]: make sure this works
if (successful)
{
hasher.Append(hashBuffer.AsBuffer(0, count));
}
offset += count;
if (!successful || offset == endOffset)
{
object hash = null;
if (successful)
{
hash = hasher.GetValueAndReset().ToArray();
}
ClientEngine.BufferManager.FreeBuffer(ref hashBuffer);
ClientEngine.MainLoop.Queue(delegate { callback(hash); });
}
else
{
count = (int)Math.Min(Piece.BlockSize, endOffset - offset);
QueueRead(manager, offset, hashBuffer, count, readCallback);
}
};
count = (int)Math.Min(Piece.BlockSize, endOffset - offset);
QueueRead(manager, offset, hashBuffer, count, readCallback);
}
void QueueWrite(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (Thread.CurrentThread == IOLoop.Thread)
{
PerformWrite(io);
_cache.Enqueue(io);
}
else
{
lock (_bufferLock)
{
_bufferedWrites.Enqueue(io);
if (_bufferedWrites.Count == 1)
{
IOLoop.Queue(_loopTask);
}
}
}
}
void QueueWrite(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (Thread.CurrentThread == IOLoop.thread)
{
PerformWrite(io);
cache.Enqueue(io);
}
else
{
lock (bufferLock)
{
bufferedWrites.Enqueue(io);
if (bufferedWrites.Count == 1)
{
DiskManager.IOLoop.Queue(LoopTask);
}
}
}
}
private void QueueWrite(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (IoLoop.IsInCurrentThread())
{
PerformWrite(io);
_cache.Enqueue(io);
}
else
{
lock (_bufferLock)
{
_bufferedWrites.Enqueue(io);
if (_bufferedWrites.Count == 1)
{
IoLoop.Queue(_loopTask);
}
}
}
}
void QueueRead(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (Task.CurrentId == IOLoop.thread.Id)
{
PerformRead(io);
cache.Enqueue(io);
}
else
{
lock (bufferLock)
{
bufferedReads.Enqueue(io);
if (bufferedReads.Count == 1)
{
DiskManager.IOLoop.Queue(LoopTask);
}
}
}
}
internal void QueueWrite(TorrentManager manager, long offset, byte[] buffer, int count, DiskIOCallback callback)
{
var io = _cache.Dequeue();
io.Initialise(manager, buffer, offset, count, manager.Torrent.PieceLength, manager.Torrent.Files);
QueueWrite(io, callback);
}
void QueueWrite(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (Task.CurrentId == IOLoop.thread.Id) {
PerformWrite(io);
cache.Enqueue (io);
}
else
lock (bufferLock)
{
bufferedWrites.Enqueue(io);
if (bufferedWrites.Count == 1)
DiskManager.IOLoop.Queue(LoopTask);
}
}
internal void QueueWrite(TorrentManager manager, long offset, byte[] buffer, int count, DiskIOCallback callback)
{
BufferedIO io = cache.Dequeue();
io.Initialise(manager, buffer, offset, count, manager.Torrent.PieceLength, manager.Torrent.Files);
QueueWrite(io, callback);
}
void QueueRead(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (Thread.CurrentThread == IOLoop.thread) {
PerformRead(io);
cache.Enqueue (io);
}
else
lock (bufferLock)
{
bufferedReads.Enqueue(io);
if (bufferedReads.Count == 1)
DiskManager.IOLoop.Queue(LoopTask);
}
}
void QueueWrite(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (Thread.CurrentThread == IOLoop.Thread) {
PerformWrite(io);
_cache.Enqueue (io);
}
else
lock (_bufferLock)
{
_bufferedWrites.Enqueue(io);
if (_bufferedWrites.Count == 1)
IOLoop.Queue(_loopTask);
}
}
public void Initialise(TorrentManager manager, byte[] buffer, long offset, int count, int pieceLength, IList<TorrentFile> files)
{
this.actualCount = 0;
this.buffer = buffer;
this.callback = null;
this.complete = false;
this.count = count;
this.files = files;
this.manager = manager;
this.offset = offset;
this.peerId = null;
this.pieceLength = pieceLength;
}
private void QueueWrite(BufferedIO io, DiskIOCallback callback)
{
io.Callback = callback;
if (IoLoop.IsInCurrentThread())
{
PerformWrite(io);
_cache.Enqueue(io);
}
else
lock (_bufferLock)
{
_bufferedWrites.Enqueue(io);
if (_bufferedWrites.Count == 1)
IoLoop.Queue(_loopTask);
}
}
