aboutsummaryrefslogtreecommitdiff
path: root/descriptor.go
blob: a2574bf351c2644a28cbaf867f9295e44f54e9bf (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package mp4

// descriptor implements MPEG-4 descriptor parsing for esds boxes.

var tagToName = map[byte]string{
	0x03: "ESDescriptor",
	0x04: "DecoderConfigDescriptor",
	0x05: "DecoderSpecificInfo",
	0x06: "SLConfigDescriptor",
}

type descriptor struct {
	tag      byte
	tagName  string
	length   int
	oti      byte
	buffer   []byte
	children map[string]*descriptor
}

func decodeDescriptor(buf []byte, start, end int) *descriptor {
	if start >= end {
		return nil
	}
	tag := buf[start]
	ptr := start + 1
	length := 0
	for ptr < end {
		lenByte := buf[ptr]
		ptr++
		length = (length << 7) | int(lenByte&0x7f)
		if lenByte&0x80 == 0 {
			break
		}
	}

	tagName := tagToName[tag]
	d := &descriptor{
		tag:      tag,
		tagName:  tagName,
		length:   (ptr - start) + length,
		children: make(map[string]*descriptor),
	}

	switch tagName {
	case "ESDescriptor":
		decodeESDescriptor(d, buf, ptr, end)
	case "DecoderConfigDescriptor":
		decodeDecoderConfigDescriptor(d, buf, ptr, end)
	case "DecoderSpecificInfo":
		dEnd := ptr + length
		if dEnd > end {
			dEnd = end
		}
		d.buffer = buf[ptr:dEnd]
	default:
		dEnd := min(ptr+length, end)
		d.buffer = buf[ptr:dEnd]
	}

	return d
}

func decodeDescriptorArray(buf []byte, start, end int) map[string]*descriptor {
	m := make(map[string]*descriptor)
	ptr := start
	for ptr+2 <= end {
		desc := decodeDescriptor(buf, ptr, end)
		if desc == nil {
			break
		}
		ptr += desc.length
		name := desc.tagName
		if name == "" {
			continue
		}
		m[name] = desc
	}
	return m
}

func decodeESDescriptor(d *descriptor, buf []byte, start, end int) {
	if start+3 > end {
		return
	}
	flags := buf[start+2]
	ptr := start + 3
	if flags&0x80 != 0 {
		ptr += 2
	}
	if flags&0x40 != 0 {
		if ptr >= end {
			return
		}
		l := int(buf[ptr])
		ptr += l + 1
	}
	if flags&0x20 != 0 {
		ptr += 2
	}
	d.children = decodeDescriptorArray(buf, ptr, end)
}

func decodeDecoderConfigDescriptor(d *descriptor, buf []byte, start, end int) {
	if start >= end {
		return
	}
	d.oti = buf[start]
	d.children = decodeDescriptorArray(buf, start+13, end)
}