Disposing objects received via the GStreamer bus

[JakubVanek]

Hi!

I've recently been tracking down "leaking" GStreamer objects in my application. I've found that if I add a STATE_CHANGED listener to Bus, over time my application starts to hold references to various Elements within the pipeline. Is there a way to manually drop the Java references to these elements? I've tried using invalidate() and close(). However, these do not really work the way I'd like them to. They do free the element, but they free event the elements that I'm holding elsewhere in the application (e.g. WebRTCBins and similar). Ideally, I would like to not let Java hold references to elements that are not reachable from elsewhere (I can .close() those elements). Is there a better solution than manually keeping a list "known" object references?

Thank you,

Jakub

[neilcsmith-net]

The bindings cache references that are reachable from elsewhere, including via GObject references. You probably want to leave them cached. Why do you think you have a problem?

[neilcsmith-net]

Makes sense. You can look at using close() / dispose() in the callback, but only on that object. Don't use invalidate() - that will cause a leak.

You could use dispose() on the NiceAgent object when you dispose of the bin - can you access by name at that point?

If you can manage this without the STATE_CHANGED callback, try and do so. That one creates a lot of proxy objects. You could also look at registering a Bus message listener. You should be able to register for state-changed with https://javadoc.io/static/org.freedesktop.gstreamer/gst1-java-core/1.4.0/org/freedesktop/gstreamer/Bus.html#connect-java.lang.String-org.freedesktop.gstreamer.Bus.MESSAGE- if I remember correctly! The source object is then only created lazily, although you should eagerly dispose the message in the callback.

There is some long term thought around "scopes" that would allow to dispose of all proxies created by a certain bus, under a certain bin, etc.

[JakubVanek]

Creating a custom bus message listener indeed did help, thank you! I had add some more hacks to filter the event based on the type of the sending element. The solution based on the default Bus.connect(STATE_CHANGED) looks like this:

import com.sun.jna.ptr.IntByReference;
import org.freedesktop.gstreamer.Bus;
import org.freedesktop.gstreamer.Pipeline;
import org.freedesktop.gstreamer.State;
import org.freedesktop.gstreamer.glib.NativeEnum;
import org.freedesktop.gstreamer.lowlevel.GstBusAPI;
import org.freedesktop.gstreamer.lowlevel.GstMessageAPI;

public class StateChangeLogging {
    /**
     * Register a native-memory-friendly listener for pipeline-wide
     * state changes.
     */
    public static void listenForPipelineStateChanges(Bus bus, Bus.STATE_CHANGED callback) {
        bus.connect(Bus.STATE_CHANGED.class, callback,
                (GstBusAPI.BusCallback) (bus1, msg, data) -> {
                    if (!msg.getSource().getGType().getTypeName().equals(Pipeline.GTYPE_NAME)) {
                        return true;
                    }
                    IntByReference oldPtr = new IntByReference();
                    IntByReference currentPtr = new IntByReference();
                    IntByReference pendingPtr = new IntByReference();
                    GstMessageAPI.GSTMESSAGE_API.gst_message_parse_state_changed(msg, oldPtr, currentPtr, pendingPtr);
                    State old = NativeEnum.fromInt(State.class, oldPtr.getValue());
                    State current = NativeEnum.fromInt(State.class, currentPtr.getValue());
                    State pending = NativeEnum.fromInt(State.class, pendingPtr.getValue());

                    callback.stateChanged(null, old, current, pending);
                    return true;
                }
        );
    }
}

[neilcsmith-net]

That's not the method I suggested using. Using anything in lowlevel is liable to break from one version of the bindings to the next.

[neilcsmith-net]

@JakubVanek what I meant incidentally was that you can do something like -

bus.connect("state-changed", (bus, message) -> {
  try (message) {
    StateChangedMessage state = (StateChangedMessage) message;
    System.out.println("State old : " + state.getOldState());
    System.out.println("State new : " + state.getNewState());
    System.out.println("State pending : " + state.getPendingState());
  }
});

That doesn't of course help in filtering the source, although if you are only checking for state changes of the pipeline itself, you probably want to do something else anyway.

[JakubVanek]

I see, I looked at the callback with Message as an argument, but given that the filtering I wanted to do, it wouldn't work (this is my mistake, I did not realize this earlier). I currently only log some messages in the callback, so I'm OK-ish with doing it the hacky way. I don't need the callback that much, but I prefer having it as it gives me some extra context about what is happening with the pipeline.