/// <summary> /// Starts or resumes the clock. /// </summary> public void Play() { using (Locker.AcquireWriterLock()) { if (Chrono.IsRunning) { return; } Chrono.Start(); } }
/// <summary> /// Sets a new position value atomically. /// </summary> /// <param name="value">The new value that the position porperty will hold.</param> public void Update(TimeSpan value) { using (_locker.AcquireWriterLock()) { var resume = _chrono.IsRunning; _chrono.Reset(); _offsetTicks = value.Ticks; if (resume) { _chrono.Start(); } } }
/// <summary> /// Tries the acquire a writer lock on the unmanaged buffer. /// Returns false if the buffer has been disposed. /// </summary> /// <param name="locker">The locker.</param> /// <returns>The disposable lock</returns> public bool TryAcquireWriterLock(out IDisposable locker) { locker = null; lock (SyncLock) { if (m_IsDisposed) { return(false); } locker = Locker.AcquireWriterLock(); return(true); } }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="alsoManaged"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool alsoManaged) { lock (SyncLock) { if (m_IsDisposed) { return; } if (alsoManaged) { // Dispose managed state (managed objects). } // Free unmanaged resources (unmanaged objects) and override a finalizer below. using (Locker.AcquireWriterLock()) { Deallocate(); } // set large fields to null. Locker.Dispose(); Locker = null; m_IsDisposed = true; } }
/// <summary> /// Gets or sets the <see cref="AVPacket"/> at the specified index. /// </summary> /// <value> /// The <see cref="AVPacket"/>. /// </value> /// <param name="index">The index.</param> /// <returns>The packet reference</returns> private AVPacket *this[int index] { get { using (Locker.AcquireReaderLock()) { return((AVPacket *)PacketPointers[index]); } } set { using (Locker.AcquireWriterLock()) { PacketPointers[index] = (IntPtr)value; } } }
/// <summary> /// Skips the specified amount requested bytes to be read. /// </summary> /// <param name="requestedBytes">The requested bytes.</param> /// <exception cref="InvalidOperationException">When requested bytes GT readable count</exception> public void Skip(int requestedBytes) { using (Locker.AcquireWriterLock()) { if (requestedBytes > m_ReadableCount) { throw new InvalidOperationException( $"Unable to skip {requestedBytes} bytes. Only {m_ReadableCount} bytes are available for skipping"); } m_ReadIndex += requestedBytes; m_ReadableCount -= requestedBytes; if (m_ReadIndex >= m_Length) { m_ReadIndex = 0; } } }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public void Dispose() { using (Locker.AcquireWriterLock()) { while (PoolBlocks.Count > 0) { var block = PoolBlocks.Dequeue(); block.Dispose(); } for (var i = PlaybackBlocks.Count - 1; i >= 0; i--) { var block = PlaybackBlocks[i]; PlaybackBlocks.RemoveAt(i); block.Dispose(); } } Locker.Dispose(); Locker = null; }