matroska: Assume master with unknown size has ended if a valid parent…

… is found

Major refactor of ebml code generator, now decoupled from fq code
Cleanup element descriptions a bit, a bit shorter and less clutter
Cleanup old comments

format/matroska/ebml/ebml.go

@@ -1,48 +1,100 @@
 package ebml
 
-import "github.com/wader/fq/pkg/scalar"
+type ID int
 
-type Type int
+type Element interface {
+	GetType() string
+	GetID() ID
+	GetParentID() ID
+	GetName() string
+	GetDefinition() string
+}
 
-const (
-	Unknown Type = iota
-	Integer
-	Uinteger
-	Float
-	String
-	UTF8
-	Date
-	Binary
-	Master
-)
+type Enum struct {
+	Name        string
+	Description string
+}
 
-var TypeNames = map[Type]string{
-	Unknown:  "unknown",
-	Integer:  "integer",
-	Uinteger: "uinteger",
-	Float:    "float",
-	String:   "string",
-	UTF8:     "utf8",
-	Date:     "data",
-	Binary:   "binary",
-	Master:   "master",
+type ElementType struct {
+	ID         ID
+	ParentID   ID
+	Name       string
+	Definition string
 }
 
-type Attribute struct {
-	Name          string
-	Type          Type
-	Tag           Tag
-	Definition    string
-	IntegerEnums  scalar.SintMap
-	UintegerEnums scalar.UintMap
-	StringEnums   scalar.StrMap
+func (e *ElementType) GetType() string       { return "" }
+func (e *ElementType) GetID() ID             { return e.ID }
+func (e *ElementType) GetParentID() ID       { return e.ParentID }
+func (e *ElementType) GetName() string       { return e.Name }
+func (e *ElementType) GetDefinition() string { return e.Definition }
+
+type ElementScalarType[T comparable] struct {
+	ElementType
+	Enums map[T]Enum
+}
+
+func (e *ElementScalarType[T]) GetEnum() map[T]Enum { return e.Enums }
+
+type Unknown struct{ ElementType }
+
+func (*Unknown) GetType() string { return "unknown" }
+
+type Integer ElementScalarType[int64]
+
+func (*Integer) GetType() string { return "integer" }
+
+type Uinteger ElementScalarType[uint64]
+
+func (*Uinteger) GetType() string { return "uinteger" }
+
+type Float ElementScalarType[float64]
+
+func (*Float) GetType() string { return "float" }
+
+type String ElementScalarType[string]
+
+func (*String) GetType() string { return "string" }
+
+type UTF8 ElementScalarType[string]
+
+func (*UTF8) GetType() string { return "utf8" }
+
+type Date struct{ ElementType }
+
+func (*Date) GetType() string { return "date" }
+
+type Binary struct{ ElementType }
+
+func (*Binary) GetType() string { return "binary" }
+
+type Master struct {
+	ElementType
+	Master map[ID]Element
 }
 
-type Tag map[uint64]Attribute
+func (e *Master) GetType() string           { return "master" }
+func (e *Master) GetMaster() map[ID]Element { return e.Master }
+
+const (
+	RootID = 0
+
+	CRC32ID = 0xbf
+	VoidID  = 0xec
+)
+
+var Global = &Master{
+	ElementType: ElementType{
+		ID:       -1,
+		ParentID: -1,
+		Name:     "",
+	},
+	Master: map[ID]Element{
+		CRC32ID: &Binary{ElementType: ElementType{Name: "crc32"}},
+		VoidID:  &Binary{ElementType: ElementType{Name: "void"}},
+	},
+}
 
 const (
-	CRC32ID              = 0xbf
-	VoidID               = 0xec
 	HeaderID             = 0x1a45dfa3
 	EBMLVersionID        = 0x4286
 	EBMLReadVersionID    = 0x42f7
@@ -53,17 +105,35 @@ const (
 	DocTypeReadVersionID = 0x4285
 )
 
-var Global = Tag{
-	CRC32ID: {Name: "crc32", Type: Binary},
-	VoidID:  {Name: "void", Type: Binary},
+var Header = &Master{
+	ElementType: ElementType{
+		ID:       HeaderID,
+		ParentID: RootID,
+		Name:     "ebml",
+	},
+	Master: map[ID]Element{
+		EBMLVersionID:        &Uinteger{ElementType: ElementType{Name: "ebml_version"}},
+		EBMLReadVersionID:    &Uinteger{ElementType: ElementType{Name: "ebml_read_version"}},
+		EBMLMaxIDLengthID:    &Uinteger{ElementType: ElementType{Name: "ebml_max_id_length"}},
+		EBMLMaxSizeLengthID:  &Uinteger{ElementType: ElementType{Name: "ebml_max_size_length"}},
+		DocTypeID:            &String{ElementType: ElementType{Name: "doc_type"}},
+		DocTypeVersionID:     &Uinteger{ElementType: ElementType{Name: "doc_type_version"}},
+		DocTypeReadVersionID: &Uinteger{ElementType: ElementType{Name: "doc_type_read_version"}},
+	},
 }
 
-var Header = Tag{
-	EBMLVersionID:        {Name: "ebml_version", Type: Uinteger},
-	EBMLReadVersionID:    {Name: "ebml_read_version", Type: Uinteger},
-	EBMLMaxIDLengthID:    {Name: "ebml_max_id_length", Type: Uinteger},
-	EBMLMaxSizeLengthID:  {Name: "ebml_max_size_length", Type: Uinteger},
-	DocTypeID:            {Name: "doc_type", Type: String},
-	DocTypeVersionID:     {Name: "doc_type_version", Type: Uinteger},
-	DocTypeReadVersionID: {Name: "doc_type_read_version", Type: Uinteger},
+// FindParentID find id walking parents of startID
+func FindParentID(idToElement map[ID]Element, startID ID, id ID) (Element, bool) {
+	current := idToElement[startID]
+	for {
+		if current.GetID() == id {
+			return current, true
+		}
+		var ok bool
+		current, ok = idToElement[current.GetParentID()]
+		if !ok {
+			break
+		}
+	}
+	return nil, false
 }