Как разрешить эту неуправляемую утечку памяти? [закрыто] ⇐ C#

[Anonymous]

Я написал небольшой визуализатор MPV для Avalonia с использованием OpenGL.public class MpvPlayer : IDisposable
{
private nint _mpvContext = nint.Zero;
private bool _disposed = false;
private MpvWakeupCallback? _wakeupCallback;
private MpvOpenglGetProcAddressCallback? _procAddressCallback;
private MpvRenderUpdateFn? _renderUpdateCallback;
private AutoResetEvent _eventSignal = new(false);
private Task? _backgroundWorkerTask = null;
private CancellationTokenSource _backgroundWorkerCancellationTokenSource = new();
internal event Action? OnRenderRequested;
internal GlInterface? _glInterface = null;
internal MediaControl? _mediaControl = null;
internal nint _mpvRenderContext = nint.Zero;
internal ConcurrentQueue _eventQueue = new();
private readonly Dictionary _mpvPropertyChangeEvents = new();

public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
//initialise MPV
internal void Initialise()
{
if (_glInterface is null) { throw new Exception("OpenGL interface was null. Did you bind MpvPlayer to a MediaControl?"); }
var mpv = mpv_create();
_mpvContext = mpv;
if (mpv == nint.Zero)
{
throw new Exception("Failed to create mpv context");
}
mpv_set_option_string(mpv, "vo", "libmpv");
if (mpv_initialize(mpv) < 0)
{
Console.WriteLine("MPV failed to init");
}
mpv_request_log_messages(mpv, "debug");
_procAddressCallback = GetProcAddress;
var initParams = new MpvOpenglInitParams
{
get_proc_address = Marshal.GetFunctionPointerForDelegate(_procAddressCallback),
get_proc_address_ctx = nint.Zero,
};
var enableAdvancedControl = 1;
byte[] managedParamApiType = Encoding.UTF8.GetBytes("opengl" + "\0");
unsafe
{
fixed (byte* paramApiType = managedParamApiType)
{
MpvRenderParam[] renderParams = {
new(){
type = mpv_render_param_type.MPV_RENDER_PARAM_API_TYPE, data = (void*)paramApiType,
},
new() {
type = mpv_render_param_type.MPV_RENDER_PARAM_OPENGL_INIT_PARAMS , data = &initParams
},
new() {
type = mpv_render_param_type.MPV_RENDER_PARAM_ADVANCED_CONTROL ,
data = &enableAdvancedControl
},
new()
};
fixed (MpvRenderParam* ParamPtr = &renderParams[0])
{
nint mpv_gl;
int status = mpv_render_context_create(
out mpv_gl,
mpv,
ParamPtr
);
_mpvRenderContext = mpv_gl;
_wakeupCallback = MpvEvent;
_renderUpdateCallback = MpvRenderUpdate;
mpv_set_wakeup_callback(mpv, Marshal.GetFunctionPointerForDelegate(_wakeupCallback), nint.Zero);
mpv_render_context_set_update_callback(mpv_gl, Marshal.GetFunctionPointerForDelegate(_renderUpdateCallback), nint.Zero);
}
}
}
//Start the background worker
_backgroundWorkerTask = Task.Run(() => BackgroundWorker(_backgroundWorkerCancellationTokenSource.Token));
}

//mpv event callback
private void MpvEvent(nint data)
{
Dispatcher.UIThread.Post(() =>
{
_eventSignal.Set();
_eventQueue.Enqueue(CustomEventType.Wakeup);
});
}
//mpv render callback
private void MpvRenderUpdate(nint data)
{
Dispatcher.UIThread.Post(() =>
{
_eventSignal.Set();
_eventQueue.Enqueue(CustomEventType.Render);
});
}
//get gl procedure address
private nint GetProcAddress(nint fn_ctx, [MarshalAs(UnmanagedType.LPStr)] string name)
{
//this should not be null
return _glInterface!.GetProcAddress(name);
}
//main event loop inspired by the sdl gl example in mpv-examples
private void BackgroundWorker(CancellationToken ctx)
{
while (true)
{
bool redraw = false;
_eventSignal.WaitOne();
if (ctx.IsCancellationRequested) return;
CustomEventType _ev;
while (_eventQueue.TryDequeue(out _ev))
{
if (ctx.IsCancellationRequested) return;
switch (_ev)
{
case CustomEventType.Wakeup:
Dispatcher.UIThread.Post(() =>
{
while (true)
{
if (_mpvContext.isNullPtr()) continue;
nint evPtr = mpv_wait_event(_mpvContext, 0.0);
if (evPtr == nint.Zero) break;
MpvEvent ev = Marshal.PtrToStructure(evPtr);
if (ev.event_id == MpvEventId.MPV_EVENT_NONE) break;
if (ev.event_id == MpvEventId.MPV_EVENT_PROPERTY_CHANGE)
{
var prop = Marshal.PtrToStructure(ev.data);
var name = Marshal.PtrToStringAnsi(prop.name);
if (name is null) continue;
if (prop.data == nint.Zero) continue;
if (_mpvPropertyChangeEvents.TryGetValue(name, out (object ev, MpvFormat format) _data))
{
switch (_data.format)
{
case MpvFormat.MPV_FORMAT_DOUBLE:
{
if (_data.ev is EventSource eventSource)
{
var value = Marshal.PtrToStructure(prop.data);
eventSource.Raise(this, value);
}
break;
}
case MpvFormat.MPV_FORMAT_FLAG:
{
if (_data.ev is EventSource eventSource)
{
var value = Marshal.PtrToStructure(prop.data);
eventSource.Raise(this, value);
}
break;
}
}
}
}
}
});
break;
case CustomEventType.Render:
if (_mpvRenderContext.isNullPtr()) continue;
var flags = mpv_render_context_update(_mpvRenderContext);
if ((flags & (1
{
_mediaControl?.TriggerRender();
});
}
}
}

//dispose
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
}

mpv_set_wakeup_callback(_mpvContext, nint.Zero, nint.Zero);
if (!_mpvRenderContext.isNullPtr())
mpv_render_context_set_update_callback(_mpvRenderContext, nint.Zero, nint.Zero);
foreach (var p in _mpvPropertyChangeEvents.Values)
{
if (p.Item1 is IDisposable disposable) disposable.Dispose();
}
_mpvPropertyChangeEvents.Clear();
mpv_unobserve_property(_mpvContext, 0);
_backgroundWorkerCancellationTokenSource.Cancel();
_eventSignal.Set();
_backgroundWorkerTask?.Wait(300);
_mpvPropertyChangeEvents.Clear();
if (!_mpvRenderContext.isNullPtr())
{
mpv_render_context_free(_mpvRenderContext);
_mpvRenderContext = nint.Zero;
}
if (!_mpvContext.isNullPtr())
{
mpv_destroy(_mpvContext);
_mpvContext = nint.Zero;
}
_disposed = true;
}
}
}
< /code>
-------- Редактировать -------- < /p>
Я отредактировал фрагмент кода выше, чтобы содержать только важные биты. Я также добавил комментарии, чтобы прояснить, что делает каждый метод. initialIse (), но это не так.

Подробнее здесь: https://stackoverflow.com/questions/797 ... emory-leak