328 lines
6.9 KiB
Go
328 lines
6.9 KiB
Go
package pulseaudio
|
|
|
|
import (
|
|
"io"
|
|
)
|
|
|
|
type Server struct {
|
|
PackageName string
|
|
PackageVersion string
|
|
User string
|
|
Hostname string
|
|
SampleSpec sampleSpec
|
|
DefaultSink string
|
|
DefaultSource string
|
|
Cookie uint32
|
|
ChannelMap channelMap
|
|
}
|
|
|
|
func (s *Server) ReadFrom(r io.Reader) (int64, error) {
|
|
return 0, bread(r,
|
|
stringTag, &s.PackageName,
|
|
stringTag, &s.PackageVersion,
|
|
stringTag, &s.User,
|
|
stringTag, &s.Hostname,
|
|
&s.SampleSpec,
|
|
stringTag, &s.DefaultSink,
|
|
stringTag, &s.DefaultSource,
|
|
uint32Tag, &s.Cookie,
|
|
&s.ChannelMap)
|
|
}
|
|
|
|
type sink struct {
|
|
Index uint32
|
|
Name string
|
|
Description string
|
|
SampleSpec sampleSpec
|
|
ChannelMap channelMap
|
|
ModuleIndex uint32
|
|
Cvolume cvolume
|
|
Muted bool
|
|
MonitorSourceIndex uint32
|
|
MonitorSourceName string
|
|
Latency uint64
|
|
Driver string
|
|
Flags uint32
|
|
PropList map[string]string
|
|
RequestedLatency uint64
|
|
BaseVolume uint32
|
|
SinkState uint32
|
|
NVolumeSteps uint32
|
|
CardIndex uint32
|
|
Ports []sinkPort
|
|
ActivePortName string
|
|
Formats []formatInfo
|
|
}
|
|
|
|
func (s *sink) ReadFrom(r io.Reader) (int64, error) {
|
|
var portCount uint32
|
|
err := bread(r,
|
|
uint32Tag, &s.Index,
|
|
stringTag, &s.Name,
|
|
stringTag, &s.Description,
|
|
&s.SampleSpec,
|
|
&s.ChannelMap,
|
|
uint32Tag, &s.ModuleIndex,
|
|
&s.Cvolume,
|
|
&s.Muted,
|
|
uint32Tag, &s.MonitorSourceIndex,
|
|
stringTag, &s.MonitorSourceName,
|
|
usecTag, &s.Latency,
|
|
stringTag, &s.Driver,
|
|
uint32Tag, &s.Flags,
|
|
&s.PropList,
|
|
usecTag, &s.RequestedLatency,
|
|
volumeTag, &s.BaseVolume,
|
|
uint32Tag, &s.SinkState,
|
|
uint32Tag, &s.NVolumeSteps,
|
|
uint32Tag, &s.CardIndex,
|
|
uint32Tag, &portCount)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
s.Ports = make([]sinkPort, portCount)
|
|
for i := uint32(0); i < portCount; i++ {
|
|
err = bread(r, &s.Ports[i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
if portCount == 0 {
|
|
err = bread(r, stringNullTag)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
} else {
|
|
err = bread(r, stringTag, &s.ActivePortName)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
|
|
var formatCount uint8
|
|
err = bread(r,
|
|
uint8Tag, &formatCount)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
s.Formats = make([]formatInfo, formatCount)
|
|
for i := uint8(0); i < formatCount; i++ {
|
|
err = bread(r, &s.Formats[i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
return 0, nil
|
|
}
|
|
|
|
type formatInfo struct {
|
|
Encoding byte
|
|
PropList map[string]string
|
|
}
|
|
|
|
func (i *formatInfo) ReadFrom(r io.Reader) (int64, error) {
|
|
return 0, bread(r, formatInfoTag, uint8Tag, &i.Encoding, &i.PropList)
|
|
}
|
|
|
|
type sinkPort struct {
|
|
Name, Description string
|
|
Pririty uint32
|
|
Available uint32
|
|
}
|
|
|
|
func (p *sinkPort) ReadFrom(r io.Reader) (int64, error) {
|
|
return 0, bread(r,
|
|
stringTag, &p.Name,
|
|
stringTag, &p.Description,
|
|
uint32Tag, &p.Pririty,
|
|
uint32Tag, &p.Available)
|
|
}
|
|
|
|
type cvolume []uint32
|
|
|
|
func (v *cvolume) ReadFrom(r io.Reader) (int64, error) {
|
|
var n byte
|
|
err := bread(r, cvolumeTag, &n)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
*v = make([]uint32, n)
|
|
return 0, bread(r, []uint32(*v))
|
|
}
|
|
|
|
type channelMap []byte
|
|
|
|
func (m *channelMap) ReadFrom(r io.Reader) (int64, error) {
|
|
var n byte
|
|
err := bread(r, channelMapTag, &n)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
*m = make([]byte, n)
|
|
_, err = r.Read(*m)
|
|
return 0, err
|
|
}
|
|
|
|
type sampleSpec struct {
|
|
Format byte
|
|
Channels byte
|
|
Rate uint32
|
|
}
|
|
|
|
func (s *sampleSpec) ReadFrom(r io.Reader) (int64, error) {
|
|
return 0, bread(r, sampleSpecTag, &s.Format, &s.Channels, &s.Rate)
|
|
}
|
|
|
|
type Card struct {
|
|
Index uint32
|
|
Name string
|
|
Module uint32
|
|
Driver string
|
|
Profiles map[string]*profile
|
|
ActiveProfile *profile
|
|
PropList map[string]string
|
|
Ports []port
|
|
}
|
|
|
|
type profile struct {
|
|
Name, Description string
|
|
Nsinks, Nsources uint32
|
|
Priority uint32
|
|
Available uint32
|
|
}
|
|
|
|
type port struct {
|
|
Card *Card
|
|
Name, Description string
|
|
Pririty uint32
|
|
Available uint32
|
|
Direction byte
|
|
PropList map[string]string
|
|
Profiles []*profile
|
|
LatencyOffset int64
|
|
}
|
|
|
|
func (p *port) ReadFrom(r io.Reader) (int64, error) {
|
|
err := bread(r,
|
|
stringTag, &p.Name,
|
|
stringTag, &p.Description,
|
|
uint32Tag, &p.Pririty,
|
|
uint32Tag, &p.Available,
|
|
uint8Tag, &p.Direction,
|
|
&p.PropList)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
var portProfileCount uint32
|
|
err = bread(r, uint32Tag, &portProfileCount)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
for j := uint32(0); j < portProfileCount; j++ {
|
|
var profileName string
|
|
err = bread(r, stringTag, &profileName)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
p.Profiles = append(p.Profiles, p.Card.Profiles[profileName])
|
|
}
|
|
return 0, bread(r, int64Tag, &p.LatencyOffset)
|
|
}
|
|
|
|
func (c *Client) sinks() ([]sink, error) {
|
|
b, err := c.request(commandGetSinkInfoList)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var sinks []sink
|
|
for b.Len() > 0 {
|
|
var sink sink
|
|
err = bread(b, &sink)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sinks = append(sinks, sink)
|
|
}
|
|
return sinks, nil
|
|
}
|
|
|
|
func (c *Client) Cards() ([]Card, error) {
|
|
b, err := c.request(commandGetCardInfoList)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var cards []Card
|
|
for b.Len() > 0 {
|
|
var card Card
|
|
var profileCount uint32
|
|
err := bread(b,
|
|
uint32Tag, &card.Index,
|
|
stringTag, &card.Name,
|
|
uint32Tag, &card.Module,
|
|
stringTag, &card.Driver,
|
|
uint32Tag, &profileCount)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
card.Profiles = make(map[string]*profile)
|
|
for i := uint32(0); i < profileCount; i++ {
|
|
var profile profile
|
|
err = bread(b,
|
|
stringTag, &profile.Name,
|
|
stringTag, &profile.Description,
|
|
uint32Tag, &profile.Nsinks,
|
|
uint32Tag, &profile.Nsources,
|
|
uint32Tag, &profile.Priority,
|
|
uint32Tag, &profile.Available)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
card.Profiles[profile.Name] = &profile
|
|
}
|
|
var portCount uint32
|
|
var activeProfileName string
|
|
err = bread(b,
|
|
stringTag, &activeProfileName,
|
|
&card.PropList,
|
|
uint32Tag, &portCount)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
card.ActiveProfile = card.Profiles[activeProfileName]
|
|
card.Ports = make([]port, portCount)
|
|
for i := uint32(0); i < portCount; i++ {
|
|
card.Ports[i].Card = &card
|
|
err = bread(b, &card.Ports[i])
|
|
}
|
|
cards = append(cards, card)
|
|
}
|
|
return cards, nil
|
|
}
|
|
|
|
func (c *Client) SetCardProfile(cardIndex uint32, profileName string) error {
|
|
_, err := c.request(commandSetCardProfile,
|
|
uint32Tag, cardIndex,
|
|
stringNullTag,
|
|
stringTag, []byte(profileName), byte(0))
|
|
return err
|
|
}
|
|
|
|
func (c *Client) setDefaultSink(sinkName string) error {
|
|
_, err := c.request(commandSetDefaultSink,
|
|
stringTag, []byte(sinkName), byte(0))
|
|
return err
|
|
}
|
|
|
|
func (c *Client) ServerInfo() (*Server, error) {
|
|
r, err := c.request(commandGetServerInfo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var s Server
|
|
err = bread(r, &s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &s, nil
|
|
}
|