Skip to content

Commit 6d66774

Browse files
Sean-DerSean-Der
committed
Use single letter method receivers
For method receivers, Go convention is to use short, often single-letter names that reflect the type's identity
1 parent 9f65b52 commit 6d66774

14 files changed

Lines changed: 391 additions & 391 deletions

File tree

‎internal/server/authorization/stream_profile_types.go‎

Lines changed: 21 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -14,36 +14,36 @@ type Profile struct {
1414

1515
var separator = "_"
1616

17-
func (profile *Profile) StreamKey() string {
18-
splitIndex := strings.LastIndex(profile.FileName, separator)
19-
return profile.FileName[:splitIndex+len(separator)-1]
17+
func (p *Profile) StreamKey() string {
18+
splitIndex := strings.LastIndex(p.FileName, separator)
19+
return p.FileName[:splitIndex+len(separator)-1]
2020
}
21-
func (profile *Profile) StreamToken() string {
22-
splitIndex := strings.LastIndex(profile.FileName, separator)
23-
return profile.FileName[splitIndex+len(separator):]
21+
func (p *Profile) StreamToken() string {
22+
splitIndex := strings.LastIndex(p.FileName, separator)
23+
return p.FileName[splitIndex+len(separator):]
2424
}
25-
func (profile *Profile) AsPublicProfile() *PublicProfile {
25+
func (p *Profile) AsPublicProfile() *PublicProfile {
2626
return &PublicProfile{
27-
StreamKey: profile.StreamKey(),
28-
IsActive: profile.IsActive,
29-
IsPublic: profile.IsPublic,
30-
MOTD: profile.MOTD,
27+
StreamKey: p.StreamKey(),
28+
IsActive: p.IsActive,
29+
IsPublic: p.IsPublic,
30+
MOTD: p.MOTD,
3131
}
3232
}
33-
func (profile *Profile) AsPersonalProfile() *PersonalProfile {
33+
func (p *Profile) AsPersonalProfile() *PersonalProfile {
3434
return &PersonalProfile{
35-
StreamKey: profile.StreamKey(),
36-
IsActive: profile.IsActive,
37-
IsPublic: profile.IsPublic,
38-
MOTD: profile.MOTD,
35+
StreamKey: p.StreamKey(),
36+
IsActive: p.IsActive,
37+
IsPublic: p.IsPublic,
38+
MOTD: p.MOTD,
3939
}
4040
}
41-
func (profile *Profile) AsAdminProfile() *AdminProfile {
41+
func (p *Profile) AsAdminProfile() *AdminProfile {
4242
return &AdminProfile{
43-
StreamKey: profile.StreamKey(),
44-
Token: profile.StreamToken(),
45-
IsPublic: profile.IsPublic,
46-
MOTD: profile.MOTD,
43+
StreamKey: p.StreamKey(),
44+
Token: p.StreamToken(),
45+
IsPublic: p.IsPublic,
46+
MOTD: p.MOTD,
4747
}
4848
}
4949

‎internal/webrtc/codecs/trackMultiCodec.go‎

Lines changed: 42 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -37,10 +37,10 @@ type TrackMultiCodec struct {
3737
currentPayloadType uint8
3838
}
3939

40-
func (track *TrackMultiCodec) ID() string { return track.id }
41-
func (track *TrackMultiCodec) RID() string { return track.rid }
42-
func (track *TrackMultiCodec) StreamID() string { return track.streamID }
43-
func (track *TrackMultiCodec) Kind() webrtc.RTPCodecType { return track.kind }
40+
func (t *TrackMultiCodec) ID() string { return t.id }
41+
func (t *TrackMultiCodec) RID() string { return t.rid }
42+
func (t *TrackMultiCodec) StreamID() string { return t.streamID }
43+
func (t *TrackMultiCodec) Kind() webrtc.RTPCodecType { return t.kind }
4444

4545
func CreateTrackMultiCodec(id string, rid string, streamID string, kind webrtc.RTPCodecType, codec TrackCodeType) *TrackMultiCodec {
4646
return &TrackMultiCodec{
@@ -52,23 +52,23 @@ func CreateTrackMultiCodec(id string, rid string, streamID string, kind webrtc.R
5252
}
5353
}
5454

55-
func (track *TrackMultiCodec) Bind(ctx webrtc.TrackLocalContext) (webrtc.RTPCodecParameters, error) {
56-
track.ssrc = ctx.SSRC()
57-
track.writeStream = ctx.WriteStream()
55+
func (t *TrackMultiCodec) Bind(ctx webrtc.TrackLocalContext) (webrtc.RTPCodecParameters, error) {
56+
t.ssrc = ctx.SSRC()
57+
t.writeStream = ctx.WriteStream()
5858

5959
var videoCodecParameters webrtc.RTPCodecParameters
6060
codecParameters := ctx.CodecParameters()
6161
for parameters := range codecParameters {
6262
switch GetAudioTrackCodec(codecParameters[parameters].MimeType) {
6363
case AudioTrackCodecOpus:
64-
track.payloadTypeOpus = uint8(codecParameters[parameters].PayloadType)
65-
track.currentPayloadType = track.payloadTypeOpus
64+
t.payloadTypeOpus = uint8(codecParameters[parameters].PayloadType)
65+
t.currentPayloadType = t.payloadTypeOpus
6666
}
6767

68-
if track.payloadTypeOpus != 0 {
69-
log.Println("WHIPSession.TrackMultiCodec: Binding AudioTrack Type for", track.streamID, "-", track.currentPayloadType)
68+
if t.payloadTypeOpus != 0 {
69+
log.Println("WHIPSession.TrackMultiCodec: Binding AudioTrack Type for", t.streamID, "-", t.currentPayloadType)
7070

71-
track.kind = webrtc.RTPCodecTypeAudio
71+
t.kind = webrtc.RTPCodecTypeAudio
7272
return webrtc.RTPCodecParameters{
7373
PayloadType: codecParameters[parameters].PayloadType,
7474
RTPCodecCapability: webrtc.RTPCodecCapability{
@@ -82,34 +82,34 @@ func (track *TrackMultiCodec) Bind(ctx webrtc.TrackLocalContext) (webrtc.RTPCode
8282

8383
switch GetVideoTrackCodec(codecParameters[parameters].MimeType) {
8484
case VideoTrackCodecH264:
85-
track.payloadTypeH264 = uint8(codecParameters[parameters].PayloadType)
86-
track.currentPayloadType = track.payloadTypeH264
85+
t.payloadTypeH264 = uint8(codecParameters[parameters].PayloadType)
86+
t.currentPayloadType = t.payloadTypeH264
8787
videoCodecParameters = codecParameters[parameters]
8888

8989
case VideoTrackCodecH265:
90-
track.payloadTypeH265 = uint8(codecParameters[parameters].PayloadType)
91-
track.currentPayloadType = track.payloadTypeH265
90+
t.payloadTypeH265 = uint8(codecParameters[parameters].PayloadType)
91+
t.currentPayloadType = t.payloadTypeH265
9292
videoCodecParameters = codecParameters[parameters]
9393

9494
case VideoTrackCodecVP8:
95-
track.payloadTypeVP8 = uint8(codecParameters[parameters].PayloadType)
96-
track.currentPayloadType = track.payloadTypeVP8
95+
t.payloadTypeVP8 = uint8(codecParameters[parameters].PayloadType)
96+
t.currentPayloadType = t.payloadTypeVP8
9797
videoCodecParameters = codecParameters[parameters]
9898

9999
case VideoTrackCodecVP9:
100-
track.payloadTypeVP9 = uint8(codecParameters[parameters].PayloadType)
101-
track.currentPayloadType = track.payloadTypeVP9
100+
t.payloadTypeVP9 = uint8(codecParameters[parameters].PayloadType)
101+
t.currentPayloadType = t.payloadTypeVP9
102102
videoCodecParameters = codecParameters[parameters]
103103

104104
case VideoTrackCodecAV1:
105-
track.payloadTypeAV1 = uint8(codecParameters[parameters].PayloadType)
106-
track.currentPayloadType = track.payloadTypeAV1
105+
t.payloadTypeAV1 = uint8(codecParameters[parameters].PayloadType)
106+
t.currentPayloadType = t.payloadTypeAV1
107107
videoCodecParameters = codecParameters[parameters]
108108
}
109109
}
110110

111-
log.Println("WHEPSession.TrackMultiCodec: Binding VideoTrack Type for", track.streamID, "-", track.currentPayloadType)
112-
track.kind = webrtc.RTPCodecTypeVideo
111+
log.Println("WHEPSession.TrackMultiCodec: Binding VideoTrack Type for", t.streamID, "-", t.currentPayloadType)
112+
t.kind = webrtc.RTPCodecTypeVideo
113113
return webrtc.RTPCodecParameters{
114114
RTPCodecCapability: webrtc.RTPCodecCapability{
115115
MimeType: videoCodecParameters.MimeType,
@@ -121,40 +121,40 @@ func (track *TrackMultiCodec) Bind(ctx webrtc.TrackLocalContext) (webrtc.RTPCode
121121
}, nil
122122
}
123123

124-
func (track *TrackMultiCodec) Unbind(context webrtc.TrackLocalContext) error {
124+
func (t *TrackMultiCodec) Unbind(context webrtc.TrackLocalContext) error {
125125
return nil
126126
}
127127

128-
func (track *TrackMultiCodec) WriteRTP(packet *rtp.Packet, codec TrackCodeType) error {
129-
packet.SSRC = uint32(track.ssrc)
128+
func (t *TrackMultiCodec) WriteRTP(packet *rtp.Packet, codec TrackCodeType) error {
129+
packet.SSRC = uint32(t.ssrc)
130130

131-
if codec != track.codec {
132-
log.Println("WHEPSession.TrackMultiCodec.WriteRTP: Setting Codec on", track.streamID, "(", track.RID(), ")", "from", track.codec, "to", codec)
133-
track.codec = codec
131+
if codec != t.codec {
132+
log.Println("WHEPSession.TrackMultiCodec.WriteRTP: Setting Codec on", t.streamID, "(", t.RID(), ")", "from", t.codec, "to", codec)
133+
t.codec = codec
134134

135-
switch track.codec {
135+
switch t.codec {
136136
case VideoTrackCodecH264:
137-
track.currentPayloadType = track.payloadTypeH264
137+
t.currentPayloadType = t.payloadTypeH264
138138
case VideoTrackCodecH265:
139-
track.currentPayloadType = track.payloadTypeH265
139+
t.currentPayloadType = t.payloadTypeH265
140140
case VideoTrackCodecVP8:
141-
track.currentPayloadType = track.payloadTypeVP8
141+
t.currentPayloadType = t.payloadTypeVP8
142142
case VideoTrackCodecVP9:
143-
track.currentPayloadType = track.payloadTypeVP9
143+
t.currentPayloadType = t.payloadTypeVP9
144144
case VideoTrackCodecAV1:
145-
track.currentPayloadType = track.payloadTypeAV1
145+
t.currentPayloadType = t.payloadTypeAV1
146146
case AudioTrackCodecOpus:
147-
track.currentPayloadType = track.payloadTypeOpus
147+
t.currentPayloadType = t.payloadTypeOpus
148148
}
149149
}
150150

151-
packet.PayloadType = track.currentPayloadType
151+
packet.PayloadType = t.currentPayloadType
152152

153-
if _, err := track.writeStream.WriteRTP(&packet.Header, packet.Payload); err != nil {
154-
track.errorCount += 1
153+
if _, err := t.writeStream.WriteRTP(&packet.Header, packet.Payload); err != nil {
154+
t.errorCount += 1
155155

156-
if track.errorCount%50 == 0 {
157-
log.Println("WHIPSession.TrackMultiCodec.WriteRTP.Error(", track.errorCount, ")", err)
156+
if t.errorCount%50 == 0 {
157+
log.Println("WHIPSession.TrackMultiCodec.WriteRTP.Error(", t.errorCount, ")", err)
158158
return err
159159
}
160160
}

‎internal/webrtc/sessions/manager/manager.go‎

Lines changed: 38 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -13,14 +13,14 @@ import (
1313
)
1414

1515
// Prepare the WHIP Session Manager
16-
func (manager *SessionManager) Setup() {
16+
func (m *SessionManager) Setup() {
1717
log.Println("WHIPSessionManager.Setup")
1818

19-
manager.sessions = make(map[string]*session.Session)
19+
m.sessions = make(map[string]*session.Session)
2020
}
2121

2222
// Add new session
23-
func (manager *SessionManager) addSession(profile authorization.PublicProfile) (s *session.Session, err error) {
23+
func (m *SessionManager) addSession(profile authorization.PublicProfile) (s *session.Session, err error) {
2424
log.Println("SessionManager.AddWHIPSession")
2525
activeContext, activeContextCancel := context.WithCancel(context.Background())
2626

@@ -38,30 +38,30 @@ func (manager *SessionManager) addSession(profile authorization.PublicProfile) (
3838
}
3939

4040
s.HasHost.Store(true)
41-
manager.sessionsLock.Lock()
42-
manager.sessions[profile.StreamKey] = s
43-
manager.sessionsLock.Unlock()
41+
m.sessionsLock.Lock()
42+
m.sessions[profile.StreamKey] = s
43+
m.sessionsLock.Unlock()
4444

4545
go func() {
4646
<-activeContext.Done()
4747
log.Println("SessionManager.Session.Done")
4848

49-
manager.sessionsLock.Lock()
50-
delete(manager.sessions, profile.StreamKey)
51-
manager.sessionsLock.Unlock()
49+
m.sessionsLock.Lock()
50+
delete(m.sessions, profile.StreamKey)
51+
m.sessionsLock.Unlock()
5252

5353
}()
5454

5555
return s, nil
5656
}
5757

5858
// Get the stream requested, or create it, and add it to the sessions context
59-
func (manager *SessionManager) GetOrAddSession(profile authorization.PublicProfile, isWHIP bool) (session *session.Session, err error) {
60-
session, ok := manager.GetSessionByID(profile.StreamKey)
59+
func (m *SessionManager) GetOrAddSession(profile authorization.PublicProfile, isWHIP bool) (session *session.Session, err error) {
60+
session, ok := m.GetSessionByID(profile.StreamKey)
6161

6262
if !ok {
6363
log.Println("SessionManager.GetOrAddStream: Adding", profile.StreamKey)
64-
session, err = manager.addSession(profile)
64+
session, err = m.addSession(profile)
6565
} else if isWHIP {
6666
log.Println("SessionManager.GetOrAddStream: Updating", profile.StreamKey)
6767
session.UpdateStreamStatus(profile)
@@ -71,23 +71,23 @@ func (manager *SessionManager) GetOrAddSession(profile authorization.PublicProfi
7171
}
7272

7373
// Get Session by id
74-
func (manager *SessionManager) GetSessionByID(streamKey string) (session *session.Session, foundSession bool) {
74+
func (m *SessionManager) GetSessionByID(streamKey string) (session *session.Session, foundSession bool) {
7575
log.Println("SessionManager.GetSessionByID", streamKey)
7676

77-
manager.sessionsLock.RLock()
78-
defer manager.sessionsLock.RUnlock()
77+
m.sessionsLock.RLock()
78+
defer m.sessionsLock.RUnlock()
7979

80-
session, foundSession = manager.sessions[streamKey]
80+
session, foundSession = m.sessions[streamKey]
8181
return session, foundSession
8282
}
8383

8484
// Gets the current state of all sessions
85-
func (manager *SessionManager) GetSessionStates(includePrivateStreams bool) (result []session.StreamSessionState) {
85+
func (m *SessionManager) GetSessionStates(includePrivateStreams bool) (result []session.StreamSessionState) {
8686
log.Println("SessionManager.GetSessionStates: IsAdmin", includePrivateStreams)
87-
manager.sessionsLock.RLock()
87+
m.sessionsLock.RLock()
8888
copiedSessions := make(map[string]*session.Session)
89-
maps.Copy(copiedSessions, manager.sessions)
90-
manager.sessionsLock.RUnlock()
89+
maps.Copy(copiedSessions, m.sessions)
90+
m.sessionsLock.RUnlock()
9191

9292
for _, s := range copiedSessions {
9393
s.StatusLock.RLock()
@@ -158,11 +158,11 @@ func (manager *SessionManager) GetSessionStates(includePrivateStreams bool) (res
158158
}
159159

160160
// Update the provided session information
161-
func (manager *SessionManager) UpdateProfile(profile *authorization.PersonalProfile) {
161+
func (m *SessionManager) UpdateProfile(profile *authorization.PersonalProfile) {
162162
log.Println("WHIPSessionManager.UpdateProfile")
163-
manager.sessionsLock.RLock()
164-
whipSession, ok := manager.sessions[profile.StreamKey]
165-
manager.sessionsLock.RUnlock()
163+
m.sessionsLock.RLock()
164+
whipSession, ok := m.sessions[profile.StreamKey]
165+
m.sessionsLock.RUnlock()
166166

167167
if ok {
168168
whipSession.StatusLock.Lock()
@@ -173,16 +173,16 @@ func (manager *SessionManager) UpdateProfile(profile *authorization.PersonalProf
173173
}
174174

175175
// Get Session by id
176-
func (manager *SessionManager) GetWHEPSessionByID(sessionID string) (whep *whep.WHEPSession, foundSession bool) {
177-
_, whepSession, foundSession := manager.GetSessionAndWHEPByID(sessionID)
176+
func (m *SessionManager) GetWHEPSessionByID(sessionID string) (whep *whep.WHEPSession, foundSession bool) {
177+
_, whepSession, foundSession := m.GetSessionAndWHEPByID(sessionID)
178178
return whepSession, foundSession
179179
}
180180

181-
func (manager *SessionManager) GetSessionAndWHEPByID(sessionID string) (streamSession *session.Session, whepSession *whep.WHEPSession, foundSession bool) {
182-
manager.sessionsLock.RLock()
183-
defer manager.sessionsLock.RUnlock()
181+
func (m *SessionManager) GetSessionAndWHEPByID(sessionID string) (streamSession *session.Session, whepSession *whep.WHEPSession, foundSession bool) {
182+
m.sessionsLock.RLock()
183+
defer m.sessionsLock.RUnlock()
184184

185-
for _, session := range manager.sessions {
185+
for _, session := range m.sessions {
186186
session.WHEPSessionsLock.RLock()
187187
whepSession, ok := session.WHEPSessions[sessionID]
188188
session.WHEPSessionsLock.RUnlock()
@@ -194,11 +194,11 @@ func (manager *SessionManager) GetSessionAndWHEPByID(sessionID string) (streamSe
194194
return nil, nil, false
195195
}
196196

197-
func (manager *SessionManager) GetHostSessionByID(sessionID string) (host *whip.WHIPSession, foundSession bool) {
198-
manager.sessionsLock.RLock()
199-
defer manager.sessionsLock.RUnlock()
197+
func (m *SessionManager) GetHostSessionByID(sessionID string) (host *whip.WHIPSession, foundSession bool) {
198+
m.sessionsLock.RLock()
199+
defer m.sessionsLock.RUnlock()
200200

201-
for _, session := range manager.sessions {
201+
for _, session := range m.sessions {
202202
host := session.Host.Load()
203203
if host == nil {
204204
continue
@@ -212,11 +212,11 @@ func (manager *SessionManager) GetHostSessionByID(sessionID string) (host *whip.
212212
return nil, false
213213
}
214214

215-
func (manager *SessionManager) GetSessionByHostSessionID(sessionID string) (session *session.Session, foundSession bool) {
216-
manager.sessionsLock.RLock()
217-
defer manager.sessionsLock.RUnlock()
215+
func (m *SessionManager) GetSessionByHostSessionID(sessionID string) (session *session.Session, foundSession bool) {
216+
m.sessionsLock.RLock()
217+
defer m.sessionsLock.RUnlock()
218218

219-
for _, session := range manager.sessions {
219+
for _, session := range m.sessions {
220220
host := session.Host.Load()
221221
if host == nil {
222222
continue

0 commit comments

Comments
 (0)