Rename Spec to Setting

mediadevices.go

@@ -46,7 +46,7 @@ func (m *mediaDevices) videoSelect(constraints VideoTrackConstraints) (tracker,
 	drivers := driver.Manager.Query(videoFilterFn)
 
 	var bestDriver driver.VideoDriver
-	var bestSpec driver.VideoSpec
+	var bestSetting driver.VideoSetting
 	minFitnessDist := math.Inf(1)
 
 	for _, d := range drivers {
@@ -55,19 +55,19 @@ func (m *mediaDevices) videoSelect(constraints VideoTrackConstraints) (tracker,
 		if wasClosed {
 			err := d.Open()
 			if err != nil {
-				// Skip this driver if we failed to open because we can't get the specs
+				// Skip this driver if we failed to open because we can't get the settings
 				continue
 			}
 		}
 
 		vd := d.(driver.VideoDriver)
-		for _, spec := range vd.Specs() {
-			fitnessDist := constraints.fitnessDistance(spec)
+		for _, setting := range vd.Settings() {
+			fitnessDist := constraints.fitnessDistance(setting)
 
 			if fitnessDist < minFitnessDist {
 				minFitnessDist = fitnessDist
 				bestDriver = vd
-				bestSpec = spec
+				bestSetting = setting
 			}
 		}
 
@@ -87,5 +87,5 @@ func (m *mediaDevices) videoSelect(constraints VideoTrackConstraints) (tracker,
 			return nil, fmt.Errorf("failed in opening the best video driver")
 		}
 	}
-	return newVideoTrack(m.pc, bestDriver, bestSpec, constraints.Codec)
+	return newVideoTrack(m.pc, bestDriver, bestSetting, constraints.Codec)
 }

mediastreamconstraints.go

@@ -18,7 +18,7 @@ type VideoTrackConstraints struct {
 }
 
 // fitnessDistance is an implementation for https://w3c.github.io/mediacapture-main/#dfn-fitness-distance
-func (c *VideoTrackConstraints) fitnessDistance(s driver.VideoSpec) float64 {
+func (c *VideoTrackConstraints) fitnessDistance(s driver.VideoSetting) float64 {
 	var dist float64
 
 	if s.Width != c.Width {

pkg/driver/camera_linux.go

@@ -15,7 +15,7 @@ type camera struct {
 	cam     *webcam.Webcam
 	formats map[webcam.PixelFormat]frame.Format
 	reversedFormats map[frame.Format]webcam.PixelFormat
-	specs 	[]VideoSpec
+	settings 	[]VideoSetting
 }
 
 var _ VideoAdapter = &camera{}
@@ -53,10 +53,10 @@ func (c *camera) Open() error {
 		return err
 	}
 
-	specs := make([]VideoSpec, 0)
+	settings := make([]VideoSetting, 0)
 	for format := range cam.GetSupportedFormats() {
 		for _, frameSize := range cam.GetSupportedFrameSizes(format) {
-			specs = append(specs, VideoSpec{
+			settings = append(settings, VideoSetting{
 				Width:  int(frameSize.MaxWidth),
 				Height: int(frameSize.MaxHeight),
 				FrameFormat: c.formats[format],
@@ -65,12 +65,12 @@ func (c *camera) Open() error {
 	}
 
 	c.cam = cam
-	c.specs = specs
+	c.settings = settings
 	return nil
 }
 
 func (c *camera) Close() error {
-	c.specs = nil
+	c.settings = nil
 	if c.cam == nil {
 		return nil
 	}
@@ -78,9 +78,9 @@ func (c *camera) Close() error {
 	return c.cam.StopStreaming()
 }
 
-func (c *camera) Start(spec VideoSpec, cb DataCb) error {
-	pf := c.reversedFormats[spec.FrameFormat]
-	_, _, _, err := c.cam.SetImageFormat(pf, uint32(spec.Width), uint32(spec.Height))
+func (c *camera) Start(setting VideoSetting, cb DataCb) error {
+	pf := c.reversedFormats[setting.FrameFormat]
+	_, _, _, err := c.cam.SetImageFormat(pf, uint32(setting.Width), uint32(setting.Height))
 	if err != nil {
 		return err
 	}
@@ -124,6 +124,6 @@ func (c *camera) Info() Info {
 	}
 }
 
-func (c *camera) Specs() []VideoSpec {
-	return c.specs
+func (c *camera) Settings() []VideoSetting {
+	return c.settings
 }

pkg/driver/driver.go

@@ -30,23 +30,23 @@ type Info struct {
 }
 
 type VideoCapable interface {
-	Start(spec VideoSpec, cb DataCb) error
+	Start(setting VideoSetting, cb DataCb) error
 	Stop() error
-	Specs() []VideoSpec
+	Settings() []VideoSetting
 }
 
-type VideoSpec struct {
+type VideoSetting struct {
 	Width, Height int
 	FrameFormat   frame.Format
 }
 
 type AudioCapable interface {
-	Start(spec AudioSpec, cb DataCb) error
+	Start(setting AudioSetting, cb DataCb) error
 	Stop() error
-	Specs() []AudioSpec
+	Settings() []AudioSetting
 }
 
-type AudioSpec struct {
+type AudioSetting struct {
 }
 
 type Adapter interface {

track.go

@@ -19,14 +19,14 @@ type videoTrack struct {
 	t       *webrtc.Track
 	s       *sampler
 	d       driver.VideoDriver
-	spec    driver.VideoSpec
+	setting driver.VideoSetting
 	decoder frame.Decoder
 	encoder codec.Encoder
 }
 
-func newVideoTrack(pc *webrtc.PeerConnection, d driver.VideoDriver, spec driver.VideoSpec, codecName Codec) (*videoTrack, error) {
+func newVideoTrack(pc *webrtc.PeerConnection, d driver.VideoDriver, setting driver.VideoSetting, codecName Codec) (*videoTrack, error) {
 	var err error
-	decoder, err := frame.NewDecoder(spec.FrameFormat)
+	decoder, err := frame.NewDecoder(setting.FrameFormat)
 	if err != nil {
 		return nil, err
 	}
@@ -37,8 +37,8 @@ func newVideoTrack(pc *webrtc.PeerConnection, d driver.VideoDriver, spec driver.
 	default:
 		payloadType = webrtc.DefaultPayloadTypeH264
 		encoder, err = h264.NewEncoder(h264.Options{
-			Width:        spec.Width,
-			Height:       spec.Height,
+			Width:        setting.Width,
+			Height:       setting.Height,
 			Bitrate:      1000000,
 			MaxFrameRate: 30,
 		})
@@ -58,17 +58,17 @@ func newVideoTrack(pc *webrtc.PeerConnection, d driver.VideoDriver, spec driver.
 		t:       track,
 		s:       newSampler(track.Codec().ClockRate),
 		d:       d,
-		spec:    spec,
+		setting: setting,
 		decoder: decoder,
 		encoder: encoder,
 	}
 
-	go d.Start(spec, vt.dataCb)
+	go d.Start(setting, vt.dataCb)
 	return &vt, nil
 }
 
 func (vt *videoTrack) dataCb(b []byte) {
-	img, err := vt.decoder.Decode(b, vt.spec.Width, vt.spec.Height)
+	img, err := vt.decoder.Decode(b, vt.setting.Width, vt.setting.Height)
 	if err != nil {
 		// TODO: probably do some logging here
 		return