mirror of
https://github.com/go-gst/go-gst.git
synced 2025-10-06 08:27:03 +08:00
350 lines
8.4 KiB
Go
350 lines
8.4 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"text/tabwriter"
|
|
|
|
"github.com/gotk3/gotk3/glib"
|
|
"github.com/tinyzimmer/go-gst/gst"
|
|
)
|
|
|
|
func printFieldType(s string) {
|
|
colorGreen.printIndent(24, s)
|
|
}
|
|
|
|
func printFieldName(s string) {
|
|
colorOrange.print(s)
|
|
colorReset.print(": ")
|
|
}
|
|
|
|
func printFieldValue(s string) {
|
|
colorCyan.printf("%s ", s)
|
|
}
|
|
|
|
// ByName implements sort. Interface based on the Name field.
|
|
type ByName []*gst.ParameterSpec
|
|
|
|
func (a ByName) Len() int { return len(a) }
|
|
func (a ByName) Less(i, j int) bool { return a[i].Name < a[j].Name }
|
|
func (a ByName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
|
|
// ByValue implements sort. Interface based on the Value field.
|
|
type ByValue []*gst.FlagsValue
|
|
|
|
func (a ByValue) Len() int { return len(a) }
|
|
func (a ByValue) Less(i, j int) bool { return a[i].Value < a[j].Value }
|
|
func (a ByValue) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
|
|
|
func printObjectPropertiesInfo(obj *gst.Object, description string) {
|
|
colorOrange.printf("%s:\n", description)
|
|
|
|
// for now this function only handles elements
|
|
|
|
props := obj.ListProperties()
|
|
sort.Sort(ByName(props))
|
|
|
|
for _, param := range props {
|
|
defer param.Unref()
|
|
|
|
colorBlue.printfIndent(2, "%-20s", param.Name)
|
|
colorReset.printf(": %s", param.Blurb)
|
|
|
|
colorReset.print("\n")
|
|
|
|
colorOrange.printIndent(24, "flags")
|
|
colorReset.print(": ")
|
|
colorCyan.print(param.Flags.GstFlagsString())
|
|
|
|
if !param.Flags.Has(gst.ParameterReadable) {
|
|
colorReset.print(" | ")
|
|
colorLightPurple.print("Write only")
|
|
} else if !param.Flags.Has(gst.ParameterWritable) {
|
|
colorReset.print(" | ")
|
|
colorLightPurple.print("Read only")
|
|
}
|
|
|
|
colorReset.print("\n")
|
|
|
|
// get the value and continue on any error (very unlikely)
|
|
|
|
goval, _ := param.DefaultValue.GoValue()
|
|
|
|
// skips deprecated types
|
|
|
|
switch param.ValueType {
|
|
|
|
case glib.TYPE_STRING:
|
|
printFieldType("String. ")
|
|
printFieldName("Default")
|
|
if goval == nil {
|
|
printFieldValue("null")
|
|
} else {
|
|
str, _ := param.DefaultValue.GetString()
|
|
printFieldValue(str)
|
|
}
|
|
|
|
case glib.TYPE_BOOLEAN:
|
|
var valStr string
|
|
if goval == nil {
|
|
valStr = "unknown" // edge case
|
|
} else {
|
|
b := goval.(bool)
|
|
valStr = fmt.Sprintf("%t", b)
|
|
}
|
|
printFieldType("Boolean. ")
|
|
printFieldName("Default")
|
|
printFieldValue(valStr)
|
|
|
|
case glib.TYPE_UINT:
|
|
var valStr string
|
|
if goval == nil {
|
|
valStr = "0"
|
|
} else {
|
|
v := goval.(uint)
|
|
valStr = fmt.Sprintf("%d", v)
|
|
}
|
|
printFieldType("Unsigned Integer. ")
|
|
printFieldName("Range")
|
|
min, max := param.UIntRange()
|
|
printFieldValue(fmt.Sprintf("%d - %d ", min, max))
|
|
printFieldName("Default")
|
|
printFieldValue(valStr)
|
|
|
|
case glib.TYPE_INT:
|
|
var valStr string
|
|
if goval == nil {
|
|
valStr = "0"
|
|
} else {
|
|
v := goval.(int)
|
|
valStr = fmt.Sprintf("%d", v)
|
|
}
|
|
printFieldType("Integer. ")
|
|
printFieldName("Range")
|
|
min, max := param.IntRange()
|
|
printFieldValue(fmt.Sprintf("%d - %d ", min, max))
|
|
printFieldName("Default")
|
|
printFieldValue(valStr)
|
|
|
|
case glib.TYPE_UINT64:
|
|
var valStr string
|
|
if goval == nil {
|
|
valStr = "0"
|
|
} else {
|
|
v := goval.(uint64)
|
|
valStr = fmt.Sprintf("%d", v)
|
|
}
|
|
printFieldType("Unsigned Integer64. ")
|
|
printFieldName("Range")
|
|
min, max := param.UInt64Range()
|
|
printFieldValue(fmt.Sprintf("%d - %d ", min, max))
|
|
printFieldName("Default")
|
|
printFieldValue(valStr)
|
|
|
|
case glib.TYPE_INT64:
|
|
var valStr string
|
|
if goval == nil {
|
|
valStr = "0"
|
|
} else {
|
|
v := goval.(int64)
|
|
valStr = fmt.Sprintf("%d", v)
|
|
}
|
|
printFieldType("Integer64. ")
|
|
printFieldName("Range")
|
|
min, max := param.Int64Range()
|
|
printFieldValue(fmt.Sprintf("%d - %d ", min, max))
|
|
printFieldName("Default")
|
|
printFieldValue(valStr)
|
|
|
|
case glib.TYPE_FLOAT:
|
|
var valStr string
|
|
if goval == nil {
|
|
valStr = "0"
|
|
} else {
|
|
v := goval.(float64)
|
|
valStr = fmt.Sprintf("%15.7g", v)
|
|
}
|
|
printFieldType("Float. ")
|
|
printFieldName("Range")
|
|
min, max := param.FloatRange()
|
|
printFieldValue(fmt.Sprintf("%15.7g - %15.7g ", min, max))
|
|
printFieldName("Default")
|
|
printFieldValue(valStr)
|
|
|
|
case glib.TYPE_DOUBLE:
|
|
var valStr string
|
|
if goval == nil {
|
|
valStr = "0"
|
|
} else {
|
|
v := goval.(float64)
|
|
valStr = fmt.Sprintf("%15.7g", v)
|
|
}
|
|
printFieldType("Double. ")
|
|
printFieldName("Range")
|
|
min, max := param.DoubleRange()
|
|
printFieldValue(fmt.Sprintf("%15.7g - %15.7g ", min, max))
|
|
printFieldName("Default")
|
|
printFieldValue(valStr)
|
|
|
|
default:
|
|
if param.IsCaps() {
|
|
|
|
if caps := param.GetCaps(); caps != nil {
|
|
printCaps(caps, 24)
|
|
}
|
|
|
|
} else if param.IsEnum() {
|
|
|
|
enumValues := param.GetEnumValues()
|
|
iface, _ := param.DefaultValue.GoValue()
|
|
var curVal string
|
|
if iface == nil {
|
|
curVal = "-1"
|
|
} else {
|
|
curVal = fmt.Sprintf("%v", iface)
|
|
}
|
|
var defaultStr string
|
|
for _, val := range enumValues {
|
|
if curVal == strconv.Itoa(val.Value) {
|
|
defaultStr = val.ValueNick
|
|
}
|
|
}
|
|
printFieldType(fmt.Sprintf(`Enum "%s" `, param.ValueType.Name()))
|
|
printFieldName("Default")
|
|
printFieldValue(fmt.Sprintf(`%s "%s"`, curVal, defaultStr))
|
|
colorReset.print("\n")
|
|
for idx, val := range enumValues {
|
|
w := new(tabwriter.Writer)
|
|
buf := new(bytes.Buffer)
|
|
w.Init(buf, 100, 73, 0, '\t', 0)
|
|
colorOrange.fprintfIndent(w, 27, "(%d)", val.Value)
|
|
colorReset.fprint(w, ": ")
|
|
colorCyan.fprint(w, val.ValueNick)
|
|
colorReset.fprint(w, "\t - ")
|
|
colorLightGray.fprint(w, val.ValueName)
|
|
w.Flush()
|
|
fmt.Print(buf.String())
|
|
if idx < len(enumValues)-1 {
|
|
colorReset.print("\n")
|
|
}
|
|
}
|
|
|
|
} else if param.IsFlags() {
|
|
|
|
flags := param.GetFlagValues()
|
|
sort.Sort(ByValue(flags))
|
|
flagStr := "+"
|
|
for _, flag := range flags {
|
|
flagStr += fmt.Sprintf(" %s", flag.ValueNick)
|
|
}
|
|
if flagStr == "+" {
|
|
flagStr = "(none)"
|
|
}
|
|
printFieldType(fmt.Sprintf(`Flags "%s" `, param.ValueType.Name()))
|
|
printFieldName("Default")
|
|
printFieldValue(fmt.Sprintf(`0x%08x "%s"`, param.GetDefaultFlags(), flagStr))
|
|
|
|
for idx, flag := range flags {
|
|
w := new(tabwriter.Writer)
|
|
buf := new(bytes.Buffer)
|
|
w.Init(buf, 100, 73, 0, '\t', 0)
|
|
colorOrange.fprintfIndent(w, 27, "(%d)", flag.Value)
|
|
colorReset.fprint(w, ": ")
|
|
colorCyan.fprint(w, flag.ValueNick)
|
|
colorReset.fprint(w, "\t - ")
|
|
colorLightGray.fprint(w, flag.ValueName)
|
|
w.Flush()
|
|
fmt.Print(buf.String())
|
|
if idx < len(flags)-1 {
|
|
colorReset.print("\n")
|
|
}
|
|
}
|
|
|
|
} else if param.IsObject() {
|
|
|
|
colorLightGray.printIndent(24, "Object of type ")
|
|
colorGreen.printf(`"%s"`, param.ValueType.Name())
|
|
|
|
} else if param.IsBoxed() {
|
|
|
|
colorLightGray.printIndent(24, "Boxed pointer of type ")
|
|
colorGreen.printf(`"%s"`, param.ValueType.Name())
|
|
if param.ValueType.Name() == "GstStructure" {
|
|
structure := gst.StructureFromGValue(param.DefaultValue)
|
|
if structure != nil {
|
|
for key, val := range structure.Values() {
|
|
colorReset.printIndent(26, "(gpointer) ")
|
|
colorYellow.printf("%15s:", key)
|
|
colorBlue.printf("%v", val)
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if param.IsPointer() {
|
|
|
|
colorLightGray.printIndent(24, "Pointer of type ")
|
|
colorGreen.printf(`"%s`, param.ValueType.Name())
|
|
|
|
} else if param.IsFraction() {
|
|
|
|
colorGreen.printIndent(24, "Fraction.")
|
|
|
|
} else if param.IsGstArray() {
|
|
|
|
colorGreen.printIndent(24, "GstArray.")
|
|
|
|
} else {
|
|
colorReset.printIndent(24, "Unknown type ")
|
|
colorGreen.printf(`"%s`, param.ValueType.Name())
|
|
}
|
|
}
|
|
|
|
colorReset.print("\n")
|
|
|
|
}
|
|
|
|
fmt.Println()
|
|
}
|
|
|
|
func printCaps(caps *gst.Caps, indent int) {
|
|
if caps == nil {
|
|
return
|
|
}
|
|
|
|
colorReset.print("\n")
|
|
defer func() { colorReset.print("\n") }()
|
|
|
|
if caps.IsAny() {
|
|
colorOrange.printIndent(indent, "ANY")
|
|
return
|
|
}
|
|
|
|
if caps.IsEmpty() {
|
|
colorOrange.printIndent(indent, "EMPTY")
|
|
return
|
|
}
|
|
|
|
for i := 0; i < caps.GetSize(); i++ {
|
|
structure := caps.GetStructureAt(i)
|
|
features := caps.GetFeaturesAt(i)
|
|
|
|
if features != nil && features.IsAny() {
|
|
colorOrange.printIndent(indent+20, structure.Name())
|
|
colorLightGray.print(" (")
|
|
colorGreen.print(features.String())
|
|
colorLightGray.print(")")
|
|
} else {
|
|
colorOrange.printIndent(indent+20, structure.Name())
|
|
}
|
|
|
|
colorReset.print("\n")
|
|
for k, v := range structure.Values() {
|
|
colorCyan.printIndent(indent+10, k)
|
|
colorReset.print(": ")
|
|
colorBlue.printf("%v\n", v)
|
|
}
|
|
}
|
|
}
|