Appsink memory leak

[clintlombard]

There seems to be a memory leak (or unbounded memory growth) when using and appsink element and mapping a new sample's buffer but not copying the data out. This can be reproduced using the appsink example, and changing to the videotestsrc, as follows :

func createPipeline() (*gst.Pipeline, error) {
	gst.Init(nil)

	pipeline, err := gst.NewPipeline("")
	if err != nil {
		return nil, err
	}

	src, err := gst.NewElement("videotestsrc")
	if err != nil {
		return nil, err
	}

	// Should this actually be a *gst.Element that produces an Appsink interface like the
	// rust examples?
	sink, err := app.NewAppSink()
	if err != nil {
		return nil, err
	}

	pipeline.AddMany(src, sink.Element)
	src.Link(sink.Element)

	// Tell the appsink what format we want. It will then be the audiotestsrc's job to
	// provide the format we request.
	// This can be set after linking the two objects, because format negotiation between
	// both elements will happen during pre-rolling of the pipeline.
	sink.SetCaps(gst.NewCapsFromString(
		"video/x-raw",
	))

	// Getting data out of the appsink is done by setting callbacks on it.
	// The appsink will then call those handlers, as soon as data is available.
	sink.SetCallbacks(&app.SinkCallbacks{
		// Add a "new-sample" callback
		NewSampleFunc: func(sink *app.Sink) gst.FlowReturn {

			// Pull the sample that triggered this callback
			sample := sink.PullSample()
			if sample == nil {
				return gst.FlowEOS
			}

			// Retrieve the buffer from the sample
			buffer := sample.GetBuffer()
			if buffer == nil {
				return gst.FlowError
			}

			// At this point, buffer is only a reference to an existing memory region somewhere.
			// When we want to access its content, we have to map it while requesting the required
			// mode of access (read, read/write).
			//
			// We also know what format to expect because we set it with the caps. So we convert
			// the map directly to signed 16-bit little-endian integers.
			buffer.Map(gst.MapRead)
			defer buffer.Unmap()

			return gst.FlowOK
		},
	})

	return pipeline, nil
}

The main change from this

			samples := buffer.Map(gst.MapRead).AsInt16LESlice()
			defer buffer.Unmap()

to this

			buffer.Map(gst.MapRead)
			defer buffer.Unmap()

By not calling AsInt16LESlice() (or any of the other methods that make a copy of the data, e.g. Bytes()), the memory will grow.

I'm trying to get zero-copy access to the underlying data, as follows:

			mapinfo := buffer.Map(gst.MapRead)
			defer buffer.Unmap()
			data := unsafe.Slice((*byte)(mapinfo.Data()), mapinfo.Size())

[brucekim]

I am interested in this issue too because I also had similar problem.

Do you have any progress for this?

Could you provide runnable sample code including main()?

I want look into it later.

[clintlombard]

The only solution I could come up with using appsink was:

buffer.Map(gst.MapRead).Bytes()

which makes a copy.

However, if you use an identity element and use it's handoff signal then the no copy access works. There must be something special with appsink that breaks this.

[RSWilli]

@clintlombard move this issue to https://github.com/go-gst/go-gst (where future development of the bindings will take place) if you think it is necessary.