more work on the examples and regenerate using the gotk4 updates

examples/appsrc/main.go

@@ -0,0 +1,149 @@
+// This example shows how to use the appsrc element.
+package main
+
+import (
+	"context"
+	"fmt"
+	"image"
+	"image/color"
+	"time"
+
+	"github.com/go-gst/go-gst/pkg/gst"
+	"github.com/go-gst/go-gst/pkg/gstapp"
+	"github.com/go-gst/go-gst/pkg/gstvideo"
+)
+
+const width = 320
+const height = 240
+
+func createPipeline() (gst.Pipeline, error) {
+	println("Creating pipeline")
+	gst.Init()
+
+	// Create a pipeline
+	pipeline := gst.NewPipeline("").(gst.Pipeline)
+
+	src := gst.ElementFactoryMake("appsrc", "").(gstapp.AppSrc)
+	conv := gst.ElementFactoryMake("videoconvert", "")
+	sink := gst.ElementFactoryMake("autovideosink", "")
+
+	// Add the elements to the pipeline and link them
+	pipeline.AddMany(src, conv, sink)
+	gst.LinkMany(src, conv, sink)
+
+	// Specify the format we want to provide as application into the pipeline
+	// by creating a video info with the given format and creating caps from it for the appsrc element.
+	videoInfo := gstvideo.NewVideoInfo()
+
+	videoInfo.SetFormat(gstvideo.VideoFormatRGBA, width, height)
+	videoInfo.SetFramerate(2, 1)
+
+	src.SetCaps(videoInfo.ToCaps())
+	src.SetObjectProperty("format", gst.FormatTime)
+
+	// Initialize a frame counter
+	var i int
+
+	// Get all 256 colors in the RGB8P palette.
+	palette := gstvideo.VideoFormatGetPalette(gstvideo.VideoFormatRGB8P)
+
+	// Since our appsrc element operates in pull mode (it asks us to provide data),
+	// we add a handler for the need-data callback and provide new data from there.
+	// In our case, we told gstreamer that we do 2 frames per second. While the
+	// buffers of all elements of the pipeline are still empty, this will be called
+	// a couple of times until all of them are filled. After this initial period,
+	// this handler will be called (on average) twice per second.
+	src.ConnectNeedData(func(self gstapp.AppSrc, _ uint) {
+
+		// If we've reached the end of the palette, end the stream.
+		if i == len(palette) {
+			src.EndOfStream()
+			return
+		}
+
+		fmt.Println("Producing frame:", i)
+
+		// Create a buffer that can hold exactly one video RGBA frame.
+		buffer := gst.NewBufferAllocate(nil, uint(videoInfo.GetSize()), nil)
+
+		// For each frame we produce, we set the timestamp when it should be displayed
+		// The autovideosink will use this information to display the frame at the right time.
+		buffer.SetPTS(gst.ClockTime(time.Duration(i) * 500 * time.Millisecond))
+
+		// Produce an image frame for this iteration.
+		pixels := produceImageFrame(palette[i])
+
+		// 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).
+		// See: https://gstreamer.freedesktop.org/documentation/plugin-development/advanced/allocation.html
+		mapped, ok := buffer.Map(gst.MapWrite)
+		if !ok {
+			panic("Failed to map buffer")
+		}
+		_, err := mapped.Write(pixels)
+		if err != nil {
+			println("Failed to write to buffer:", err)
+			panic("Failed to write to buffer")
+		}
+
+		mapped.Unmap()
+
+		// Push the buffer onto the pipeline.
+		self.PushBuffer(buffer)
+
+		i++
+	})
+
+	return pipeline, nil
+}
+
+func produceImageFrame(c color.Color) []uint8 {
+	upLeft := image.Point{0, 0}
+	lowRight := image.Point{width, height}
+	img := image.NewRGBA(image.Rectangle{upLeft, lowRight})
+
+	for x := 0; x < width; x++ {
+		for y := 0; y < height; y++ {
+			img.Set(x, y, c)
+		}
+	}
+
+	return img.Pix
+}
+
+func mainLoop(pipeline gst.Pipeline) error {
+	// Start the pipeline
+
+	pipeline.SetState(gst.StatePlaying)
+
+	for msg := range pipeline.GetBus().Messages(context.Background()) {
+		switch msg.Type() {
+		case gst.MessageEos:
+			return nil
+		case gst.MessageError:
+			debug, gerr := msg.ParseError()
+			if debug != "" {
+				fmt.Println(gerr.Error(), debug)
+			}
+			return gerr
+		}
+	}
+
+	return fmt.Errorf("unexpected end of messages without EOS")
+}
+
+func main() {
+	pipeline, err := createPipeline()
+
+	if err != nil {
+		fmt.Println("Error creating pipeline:", err)
+		return
+	}
+
+	err = mainLoop(pipeline)
+
+	if err != nil {
+		fmt.Println("Error running pipeline:", err)
+	}
+}