Added some tests and refactored some constructors

pkg/gstreamer/bus.go

@@ -7,11 +7,12 @@ package gstreamer
 */
 import "C"
 import (
- "fmt"
+ "errors"
+ "runtime"
  "unsafe"
 )
 
-type Bus interface{
+type Bus interface {
  Object
 
  HavePending() bool
@@ -22,15 +23,27 @@ type bus struct {
  object
 }
 
+var (
+ ErrFailedToCreateBus = errors.New("failed to create bus")
+)
+
 func NewBus() (Bus, error) {
  cbus := C.gst_bus_new()
+ return newBusFromPointer(cbus)
+}
 
- if cbus == nil {
- return nil, fmt.Errorf("failed to create bus")
+func newBusFromPointer(pointer *C.GstBus) (Bus, error) {
+ if pointer == nil {
+ return nil, ErrFailedToCreateBus
  }
 
  bus := &bus{}
- bus.GstObject = convertPointerToObject(unsafe.Pointer(cbus))
+ bus.GstObject = convertPointerToObject(unsafe.Pointer(pointer))
+
+ runtime.SetFinalizer(bus, func(b Bus) {
+ b.Unref()
+ })
+
  return bus, nil
 }
 
@@ -40,4 +53,4 @@ func (b *bus) HavePending() bool {
 
 func (b *bus) GetBusPointer() *C.GstBus {
  return (*C.GstBus)(unsafe.Pointer(b.GstObject))
-}
+}

pkg/gstreamer/element.go

@@ -21,8 +21,10 @@ type Element interface {
 
  SetState(GstState) GstStateChangeReturn
 
- GetPadTemplate(string) PadTemplate
- RequestPad(PadTemplate, *string, Caps) Pad
+ GetPadTemplate(string) (PadTemplate, error)
+ RequestPad(PadTemplate, *string, Caps) (Pad, error)
+
+ GetBus() (Bus, error)
 
  GetElementPointer() *C.GstElement
 }
@@ -118,15 +120,15 @@ func (e *element) SetState(state GstState) GstStateChangeReturn {
  return result
 }
 
-func (e *element) GetPadTemplate(name string) PadTemplate {
+func (e *element) GetPadTemplate(name string) (PadTemplate, error) {
  cname := C.CString(name)
  defer C.free(unsafe.Pointer(cname))
 
  cpadTemplate := C.gst_element_get_pad_template(e.GetElementPointer(), cname)
  return newPadTemplateFromPointer(cpadTemplate)
 }
 
-func (e *element) RequestPad(template PadTemplate, name *string, caps Caps) Pad {
+func (e *element) RequestPad(template PadTemplate, name *string, caps Caps) (Pad, error) {
  var cname *C.char
  var ccaps *C.GstCaps
 
@@ -141,7 +143,7 @@ func (e *element) RequestPad(template PadTemplate, name *string, caps Caps) Pad
  }
 
  cpad := C.gst_element_request_pad(
- e.GetElementPointer(), 
+ e.GetElementPointer(),
  template.GetPadTemplatePointer(),
  cname,
  ccaps,
@@ -154,6 +156,11 @@ func (e *element) RequestPad(template PadTemplate, name *string, caps Caps) Pad
  return newPadFromPointer(cpad)
 }
 
+func (e *element) GetBus() (Bus, error) {
+ cbus := C.gst_element_get_bus(e.GetElementPointer())
+ return newBusFromPointer(cbus)
+}
+
 func (e *element) GetElementPointer() *C.GstElement {
  return (*C.GstElement)(unsafe.Pointer(e.GstObject))
 }

pkg/gstreamer/pad.go

@@ -7,7 +7,8 @@ package gstreamer
 import "C"
 
 import (
- "fmt"
+ "errors"
+ "runtime"
  "unsafe"
 )
 
@@ -44,69 +45,68 @@ const (
  GstPadRequest
 )
 
-func NewPad(name *string, direction GstPadDirection) (Pad, error) {
- pad := &pad{}
+var (
+ ErrFailedToCreatePadTemplate = errors.New("gstreamer: failed to create pad template")
+ ErrFailedToCreatePad = errors.New("gstreamer: failed to create pad")
+)
 
+func NewPad(name *string, direction GstPadDirection) (Pad, error) {
+ var cname *C.char
  if name == nil {
- cpad := C.gst_pad_new(nil, C.GstPadDirection(direction))
- if cpad == nil {
- return nil, fmt.Errorf("failed to create Pad")
- }
-
- pad.GstObject = convertPointerToObject(unsafe.Pointer(cpad))
+ cname = nil
  } else {
  cname := C.CString(*name)
  defer C.free(unsafe.Pointer(cname))
-
- cpad := C.gst_pad_new(nil, C.GstPadDirection(direction))
- if cpad == nil {
- return nil, fmt.Errorf("failed to create Pad")
- }
- pad.GstObject = convertPointerToObject(unsafe.Pointer(cpad))
  }
 
- return pad, nil
+ cpad := C.gst_pad_new(cname, C.GstPadDirection(direction))
+
+ return newPadFromPointer(cpad)
 }
 
 func NewPadTemplate(name *string, direction GstPadDirection, presence GstPadPresence, caps Caps) (PadTemplate, error) {
- padTemplate := &padTemplate{}
-
+ var cname *C.char
  if name == nil {
- cpadTemplate := C.gst_pad_template_new(nil, C.GstPadDirection(direction), C.GstPadPresence(presence), caps.GetCapsPointer())
- if cpadTemplate == nil {
- return nil, fmt.Errorf("failed to create PadTemplate")
- }
-
- padTemplate.GstObject = convertPointerToObject(unsafe.Pointer(cpadTemplate))
+ cname = nil
  } else {
- cpadName := C.CString(*name)
- defer C.free(unsafe.Pointer(cpadName))
-
- cpadTemplate := C.gst_pad_template_new(cpadName, C.GstPadDirection(direction), C.GstPadPresence(presence), caps.GetCapsPointer())
- if cpadTemplate == nil {
- return nil, fmt.Errorf("failed to create PadTemplate")
- }
-
- padTemplate.GstObject = convertPointerToObject(unsafe.Pointer(cpadTemplate))
+ cname := C.CString(*name)
+ defer C.free(unsafe.Pointer(cname))
  }
 
- return padTemplate, nil
+ cpadTemplate := C.gst_pad_template_new(cname, C.GstPadDirection(direction), C.GstPadPresence(presence), caps.GetCapsPointer())
+ return newPadTemplateFromPointer(cpadTemplate)
 }
 
-func newPadFromPointer(pointer *C.GstPad) Pad {
+func newPadFromPointer(pointer *C.GstPad) (Pad, error) {
+ if pointer == nil {
+ return nil, ErrFailedToCreatePadTemplate
+ }
+
  pad := &pad{}
  pad.GstObject = convertPointerToObject(unsafe.Pointer(pointer))
 
- return pad
+ runtime.SetFinalizer(pad, func(p Pad) {
+ p.Unref()
+ })
+
+ return pad, nil
 }
 
-func newPadTemplateFromPointer(pointer *C.GstPadTemplate) PadTemplate {
+func newPadTemplateFromPointer(pointer *C.GstPadTemplate) (PadTemplate, error) {
+ if pointer == nil {
+ return nil, ErrFailedToCreatePad
+ }
+
  padTemplate := &padTemplate{}
  padTemplate.GstObject = convertPointerToObject(unsafe.Pointer(pointer))
 
- return padTemplate
+ runtime.SetFinalizer(padTemplate, func(pt PadTemplate) {
+ pt.Unref()
+ })
+
+ return padTemplate, nil
 }
 
 func (pt *padTemplate) GetPadTemplatePointer() *C.GstPadTemplate {
  return (*C.GstPadTemplate)(unsafe.Pointer(pt.GstObject))
-}
+}

pkg/gstreamer/pipeline.go

@@ -24,7 +24,7 @@ type pipeline struct {
 }
 
 //NewPipeline ...
-func NewPipeline(name string) (Bin, error) {
+func NewPipeline(name string) (Pipeline, error) {
  cname := C.CString(name)
  defer C.free(unsafe.Pointer(cname))
 

test/element_test.go

@@ -6,6 +6,17 @@ import (
  "github.com/vinijabes/gostreamer/pkg/gstreamer"
 )
 
+func TestElement(t *testing.T) {
+ element, err := gstreamer.NewElement("compositor", "element")
+ ok(t, err)
+
+ template, err := element.GetPadTemplate("sink_%u")
+ ok(t, err)
+
+ _, err = element.RequestPad(template, nil, nil)
+ ok(t, err)
+}
+
 func TestFactory(t *testing.T) {
  factory, err := gstreamer.NewElementFactory("videotestsrc")
  ok(t, err)

test/pad_test.go

@@ -24,6 +24,11 @@ func TestNewPad(t *testing.T) {
  _, err := gstreamer.NewPad(&name, gstreamer.GstPadSink)
  ok(t, err)
  })
+
+ t.Run("CreateUnnamedPad", func(t *testing.T) {
+ _, err := gstreamer.NewPad(nil, gstreamer.GstPadUnknown)
+ ok(t, err)
+ })
 }
 
 func TestPad(t *testing.T) {

test/pipeline_test.go

@@ -0,0 +1,56 @@
+package tests
+
+import (
+ "testing"
+ "time"
+
+ "github.com/vinijabes/gostreamer/pkg/gstreamer"
+)
+
+func TestVideoPipeline(t *testing.T) {
+ pipeline, err := gstreamer.NewPipeline("videotest")
+ ok(t, err)
+
+ src, err := gstreamer.NewElement("videotestsrc", "source")
+ ok(t, err)
+
+ sink, err := gstreamer.NewElement("autovideosink", "sink")
+ ok(t, err)
+
+ equals(t, true, pipeline.Add(src))
+ equals(t, true, pipeline.Add(sink))
+
+ equals(t, true, src.Link(sink))
+
+ result := pipeline.SetState(gstreamer.GstStatePlaying)
+ equals(t, gstreamer.GstStateChangeAsync, result)
+
+ time.Sleep(2 * time.Second)
+
+ result = pipeline.SetState(gstreamer.GstStateNull)
+ equals(t, gstreamer.GstStateChangeSuccess, result)
+}
+
+func TestAudioPipeline(t *testing.T) {
+ pipeline, err := gstreamer.NewPipeline("audiotest")
+ ok(t, err)
+
+ src, err := gstreamer.NewElement("audiotestsrc", "source")
+ ok(t, err)
+
+ sink, err := gstreamer.NewElement("autoaudiosink", "sink")
+ ok(t, err)
+
+ equals(t, true, pipeline.Add(src))
+ equals(t, true, pipeline.Add(sink))
+
+ equals(t, true, src.Link(sink))
+
+ result := pipeline.SetState(gstreamer.GstStatePlaying)
+ equals(t, gstreamer.GstStateChangeAsync, result)
+
+ time.Sleep(2 * time.Second)
+
+ result = pipeline.SetState(gstreamer.GstStateNull)
+ equals(t, gstreamer.GstStateChangeSuccess, result)
+}