private void CompositionTarget_Rendering(object sender, EventArgs e)
{
//Core.LogInfo("Frame out");
var previousShown = _displayingFrame;
lock (_lock)
{
if (_currentQueue.Count == 0)
{
return;
}
_displayingFrame = _currentQueue.Dequeue();
}
//Core.LogInfo("Frame out");
try
{
if (_host != null) // means in fact we are initialized
{
DisplayFrame(_displayingFrame);
}
}
finally
{
previousShown?.RemoveRef();
}
}
public CefTypeKind GetTypeKind(ITypeSymbol symbol)
{
if (!symbol.Name.StartsWith("cef_"))
{
return(CefTypeKind.Unknown);
}
INamedTypeSymbol value;
if (RefCounted.TryGetValue(symbol.Name, out value) && Equals(value, symbol))
{
return(CefTypeKind.RefCounted);
}
if (Scoped.TryGetValue(symbol.Name, out value) && Equals(value, symbol))
{
return(CefTypeKind.Scoped);
}
if (Enums.TryGetValue(symbol.Name, out value) && Equals(value, symbol))
{
return(CefTypeKind.Enum);
}
if (Sized.TryGetValue(symbol.Name, out value) && Equals(value, symbol))
{
return(CefTypeKind.Sized);
}
if (Simple.TryGetValue(symbol.Name, out value) && Equals(value, symbol))
{
return(CefTypeKind.Simple);
}
throw new NotImplementedException();
}
protected override RefCounted <IEncoderContext> CreateAndOpenContextRef(EncoderSetup setup)
{
lock (this)
{
var same = _versions.All(s => setup.EqualsExceptBitrate(s.ContextSetup));
bool replace = same && _versions.Count > 0;
if (!replace)
{
DisposeVersions();
}
else
{
foreach (var version in _versions)
{
version.Context.RemoveRef();
version.Context = null;
}
}
var result = new RefCounted <IEncoderContext>(CreateAndOpenContext(setup));
if (replace)
{
foreach (var version in _versions)
{
version.Context = result.AddRef();
}
}
return(result);
}
}
public void Build()
{
foreach (INamedTypeSymbol symbol in GetSymbolsForNativeApi())
{
if (symbol.TypeKind == TypeKind.Enum)
{
Enums.Add(symbol.Name, symbol);
continue;
}
if (IsRefCountedTypeSymbol(symbol))
{
RefCounted.Add(symbol.Name, symbol);
continue;
}
if (IsScopedTypeSymbol(symbol))
{
Scoped.Add(symbol.Name, symbol);
continue;
}
if (symbol.TypeKind != TypeKind.Struct)
{
continue;
}
if (IsSizedStruct(symbol))
{
Sized.Add(symbol.Name, symbol);
continue;
}
Simple.Add(symbol.Name, symbol);
}
}
public static IObservable <TSource> UsingRefCounted <TSource, TResource>(Func <TResource> resourceFactory, Func <TResource, IObservable <TSource> > observableFactory) where TResource : IDisposable
{
RefCounted <TResource> refCounted = new RefCounted <TResource>(resourceFactory, resource => resource.Dispose());
return(Observable.Create <TSource>(
observer => UsingRefCounted(refCounted, observableFactory).Subscribe(observer)
));
}
public void OnlyInstantiateTheResourceOnFirstSubscription()
{
int instantiations = 0;
RefCounted <int> refCounted = new RefCounted <int>(() => ++ instantiations, value => -- instantiations);
using (Observables.UsingRefCounted(refCounted, value => Observable.Never <int>()).Subscribe())
{
Assert.That(instantiations, Is.EqualTo(1));
}
}
private void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
obj.Release();
obj = null;
}
disposed = true;
}
}
public void CopyFrom(StyleDataRef <T> other)
{
if (m_Ref.refCount == 1)
{
m_Ref.value.CopyFrom(ref other.m_Ref.value);
}
else
{
m_Ref.Release();
m_Ref = other.m_Ref;
m_Ref.Acquire();
}
}
public ref T Write()
{
if (m_Ref.refCount == 1)
{
return(ref m_Ref.value);
}
var oldRef = m_Ref;
m_Ref = m_Ref.Copy();
oldRef.Release();
return(ref m_Ref.value);
}
/// <summary>
/// Initializes a new instance of <see cref="CefBaseRefCounted{T}"/>.
/// </summary>
public unsafe CefBaseRefCounted()
: base(Allocate(sizeof(T)))
{
var reference = new RefCountedReference(new WeakReference <CefBaseRefCounted>(this));
GlobalSyncRoot.EnterWriteLock();
try
{
RefCounted.Add(_instance, reference);
}
finally
{
GlobalSyncRoot.ExitWriteLock();
}
}
public static IObservable <TSource> UsingRefCounted <TSource, TResource>(RefCounted <TResource> resource, Func <TResource, IObservable <TSource> > observableFactory)
{
return(Observable.Create <TSource>(
observer =>
{
resource.AddReference();
IObservable <TSource> observable = observableFactory(resource.Instance);
return new CompositeDisposable(
observable.Subscribe(observer),
Disposable.Create(resource.DropReference)
);
}
));
}
private void DirectXPresenter_Unloaded(object sender, RoutedEventArgs e)
{
if (_host != null)
{
_host.Register(null);
}
CompositionTarget.Rendering -= CompositionTarget_Rendering;
lock (_lock)
{
_currentQueue.ToList().ForEach(s => s.RemoveRef());
_currentQueue.Clear();
_displayingFrame?.RemoveRef();
_displayingFrame = null;
}
}
public void NotInstantiateTheResourceOnSubsequentSubscriptions()
{
int instantiations = 0;
RefCounted <int> refCounted = new RefCounted <int>(() => ++ instantiations, value => -- instantiations);
IObservable <int> observable = Observables.UsingRefCounted(refCounted, value => Observable.Never <int>());
using (observable.Subscribe())
{
using (observable.Subscribe())
{
Assert.That(instantiations, Is.EqualTo(1));
}
}
}
private SemaphoreSlim GetOrCreate(object key)
{
RefCounted<SemaphoreSlim> item;
lock (SemaphoreSlims)
{
if (SemaphoreSlims.TryGetValue(key, out item))
{
++item.RefCount;
}
else
{
item = new RefCounted<SemaphoreSlim>(new SemaphoreSlim(1, 1));
SemaphoreSlims[key] = item;
}
}
return item.Value;
}
private SemaphoreSlim GetOrCreate(string key)
{
RefCounted <SemaphoreSlim> item;
lock (_semaphoreSlims)
{
if (_semaphoreSlims.TryGetValue(key, out item))
{
++item.RefCount;
}
else
{
item = new RefCounted <SemaphoreSlim>(new SemaphoreSlim(1, 1));
_semaphoreSlims[key] = item;
}
}
return(item.Value);
}
private Nito.AsyncEx.AsyncReaderWriterLock GetOrCreate(object key)
{
RefCounted item;
lock (_locks)
{
if (_locks.TryGetValue(key, out item))
{
++item.RefCount;
}
else
{
item = new RefCounted();
_locks[key] = item;
}
}
return(item.Value);
}
/// <summary>
/// Returns an instance of a type that represents a <see cref="CefBaseRefCounted"/>
/// object by an unspecified pointer.
/// </summary>
/// <param name="ptr">A pointer to a ref-counted struct.</param>
/// <returns>
/// A <see cref="CefBaseRefCounted"/>-based object that corresponds to the pointer
/// or null if wrapper not found.
/// </returns>
public static CefBaseRefCounted GetInstance(IntPtr ptr)
{
RefCountedReference reference;
Internal.CefBaseRefCountedImpl.GlobalSyncRoot.EnterReadLock();
try
{
RefCounted.TryGetValue(ptr, out reference);
if (reference != null && reference.Instance.TryGetTarget(out CefBaseRefCounted instance))
{
return(instance);
}
}
finally
{
Internal.CefBaseRefCountedImpl.GlobalSyncRoot.ExitReadLock();
}
return(null);
}
private SemaphoreSlim GetOrCreate(object key)
{
RefCounted <SemaphoreSlim> refCounted;
lock (SemaphoreSlims)
{
if (SemaphoreSlims.TryGetValue(key, out refCounted))
{
++refCounted.RefCount;
}
else
{
refCounted = new RefCounted <SemaphoreSlim>(new SemaphoreSlim(1, 1));
SemaphoreSlims[key] = refCounted;
}
}
return(refCounted.Value);
}
private void DisplayFrame(RefCounted <FromPool <Frame> > rframe)
{
var frame = rframe.Instance.Item;
var dxRef = frame.DirectXResourceRef;
if (dxRef != null)
{
if (!_deviceWasTryingToInit)
{
_deviceWasTryingToInit = true;
InitDx9();
}
if (_device != null)
{
if (_sharedResource == null)
{
if (dxRef.Instance.GetDx() != _sharedResourceOwnerAttempted)
{
_sharedResourceOwnerAttempted = dxRef.Instance.GetDx();
OpenSharedResourceIfNeeded(dxRef.Instance);
}
}
else
{
OpenSharedResourceIfNeeded(dxRef.Instance);
}
}
if (_sharedResource != null)
{
DisplayAsTexture(dxRef.Instance);
}
else
{
DownloadAndDisplayAsBitmap(dxRef.Instance);
}
}
else
{
DisplayAsBitmap(frame);
}
}
#pragma warning disable CS1591
protected unsafe override void Dispose(bool disposing)
{
IntPtr key = Volatile.Read(ref _instance);
if (key != IntPtr.Zero)
{
GlobalSyncRoot.EnterWriteLock();
try
{
if (CefApi.UseUnsafeImplementation)
{
RefCountedWrapperStruct *ws = GetWrapperStructPtr((void *)key);
if (ws != null)
{
UnsafeRefCounted.Remove(ws->cppObject);
}
}
RefCounted.Remove(key);
}
finally
{
GlobalSyncRoot.ExitWriteLock();
}
#if NETFRAMEWORK
if (Environment.HasShutdownStarted)
{
if (CefStructure.IsAllocated(key)) // allow leaks to fix potential UAF
{
return;
}
}
else
#endif
if (CefStructure.Free(key))
{
return;
}
base.Dispose(disposing);
}
}
public int Write(Packet packet)
{
RemoveCurrent();
_currentFramePts = packet.Properties.Pts;
if (_dx != null)
{
_currentResource = new RefCounted <DirectXResource>(_dx.Pool.Get("passthru", DirectXResource.Desc(_width,
_height,
SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SharpDX.Direct3D11.BindFlags.ShaderResource,
SharpDX.Direct3D11.ResourceUsage.Immutable),
new SharpDX.DataRectangle(packet.Properties.DataPtr, _width * 4)));
}
else
{
_currentResource = packet.DirectXResourceRef.AddRef();
}
return(0);
}
private async Task <RefCounted <SemaphoreSlim> > GetOrCreate(object key, CancellationToken token)
{
RefCounted <SemaphoreSlim> item;
await _lock.WaitAsync(token);
try
{
if (_dict.TryGetValue(key, out item))
{
++item.RefCount;
}
else
{
item = new RefCounted <SemaphoreSlim>(new SemaphoreSlim(1, 1));
_dict[key] = item;
}
}
finally
{
_lock.Release();
}
return(item);
}
public Wrapper(RefCounted <T> o)
{
o.Get();
obj = o;
}
public void Release()
{
m_Ref.Release();
m_Ref = null;
}
/// <summary>
/// Returns a wrapper for the specified pointer.
/// </summary>
/// <typeparam name="TClass">The type of wrapper.</typeparam>
/// <param name="create">Represents a method that create a new wrapper.</param>
/// <param name="instance">The pointer to ref-counted CEF struct.</param>
/// <returns>Returns an existing or new wrapper for the specified pointer.</returns>
public unsafe static TClass Wrap <TClass>(Func <IntPtr, TClass> create, T *instance)
where TClass : CefBaseRefCounted <T>
{
if (instance == null)
{
return(null);
}
RefCountedWrapperStruct *ws = null;
CefBaseRefCounted wrapper;
IntPtr key = new IntPtr(instance);
Internal.CefBaseRefCountedImpl.GlobalSyncRoot.EnterUpgradeableReadLock();
try
{
if (CefApi.UseUnsafeImplementation)
{
ws = GetWrapperStructPtr(instance);
if (ws != null && UnsafeRefCounted.TryGetValue(ws->cppObject, out WeakReference <CefBaseRefCounted> weakRef) &&
weakRef.TryGetTarget(out wrapper))
{
((cef_base_ref_counted_t *)instance)->Release();
return((TClass)wrapper);
}
}
if (RefCounted.TryGetValue(key, out RefCountedReference reference) &&
reference.Instance.TryGetTarget(out wrapper))
{
((cef_base_ref_counted_t *)instance)->Release();
return((TClass)wrapper);
}
#if DEBUG
else if (CefStructure.IsAllocated(key))
{
throw new InvalidCefObjectException(string.Format("Unexpected access to {0}.", typeof(TClass).Name));
}
#endif
else
{
Internal.CefBaseRefCountedImpl.GlobalSyncRoot.EnterWriteLock();
try
{
TClass typedWrapper = create(key);
var weakRef = new WeakReference <CefBaseRefCounted>(typedWrapper);
RefCounted[key] = new RefCountedReference(weakRef);
if (ws != null)
{
UnsafeRefCounted[ws->cppObject] = weakRef;
}
return(typedWrapper);
}
finally
{
Internal.CefBaseRefCountedImpl.GlobalSyncRoot.ExitWriteLock();
}
}
}
finally
{
Internal.CefBaseRefCountedImpl.GlobalSyncRoot.ExitUpgradeableReadLock();
}
}
public RefCounted <DirectXResource> Render(DirectXContext dx, VideoFilterChainDescriptor filterChain, DeviceContext ctx, RefCounted <DirectXResource> input)
{
var res = Render(dx, filterChain, ctx, input.Instance);
if (ReferenceEquals(res, input.Instance))
{
return(input.AddRef());
}
else
{
return(new RefCounted <DirectXResource>(res));
}
}
public bool Equals(RefCounted <T> other) => refcount == other.refcount;
public void RemoveCurrent()
{
_currentResource?.RemoveRef();
_currentResource = null;
}
