1 files changed, 188 insertions, 0 deletions
diff --git a/vendor/github.com/pion/webrtc/v3/signalingstate.go b/vendor/github.com/pion/webrtc/v3/signalingstate.go
new file mode 100644
index 0000000..b64dffc
--- /dev/null
+++ b/vendor/github.com/pion/webrtc/v3/signalingstate.go
@@ -0,0 +1,188 @@
+package webrtc
+
+import (
+	"fmt"
+	"sync/atomic"
+
+	"github.com/pion/webrtc/v3/pkg/rtcerr"
+)
+
+type stateChangeOp int
+
+const (
+	stateChangeOpSetLocal stateChangeOp = iota + 1
+	stateChangeOpSetRemote
+)
+
+func (op stateChangeOp) String() string {
+	switch op {
+	case stateChangeOpSetLocal:
+		return "SetLocal"
+	case stateChangeOpSetRemote:
+		return "SetRemote"
+	default:
+		return "Unknown State Change Operation"
+	}
+}
+
+// SignalingState indicates the signaling state of the offer/answer process.
+type SignalingState int32
+
+const (
+	// SignalingStateStable indicates there is no offer/answer exchange in
+	// progress. This is also the initial state, in which case the local and
+	// remote descriptions are nil.
+	SignalingStateStable SignalingState = iota + 1
+
+	// SignalingStateHaveLocalOffer indicates that a local description, of
+	// type "offer", has been successfully applied.
+	SignalingStateHaveLocalOffer
+
+	// SignalingStateHaveRemoteOffer indicates that a remote description, of
+	// type "offer", has been successfully applied.
+	SignalingStateHaveRemoteOffer
+
+	// SignalingStateHaveLocalPranswer indicates that a remote description
+	// of type "offer" has been successfully applied and a local description
+	// of type "pranswer" has been successfully applied.
+	SignalingStateHaveLocalPranswer
+
+	// SignalingStateHaveRemotePranswer indicates that a local description
+	// of type "offer" has been successfully applied and a remote description
+	// of type "pranswer" has been successfully applied.
+	SignalingStateHaveRemotePranswer
+
+	// SignalingStateClosed indicates The PeerConnection has been closed.
+	SignalingStateClosed
+)
+
+// This is done this way because of a linter.
+const (
+	signalingStateStableStr             = "stable"
+	signalingStateHaveLocalOfferStr     = "have-local-offer"
+	signalingStateHaveRemoteOfferStr    = "have-remote-offer"
+	signalingStateHaveLocalPranswerStr  = "have-local-pranswer"
+	signalingStateHaveRemotePranswerStr = "have-remote-pranswer"
+	signalingStateClosedStr             = "closed"
+)
+
+func newSignalingState(raw string) SignalingState {
+	switch raw {
+	case signalingStateStableStr:
+		return SignalingStateStable
+	case signalingStateHaveLocalOfferStr:
+		return SignalingStateHaveLocalOffer
+	case signalingStateHaveRemoteOfferStr:
+		return SignalingStateHaveRemoteOffer
+	case signalingStateHaveLocalPranswerStr:
+		return SignalingStateHaveLocalPranswer
+	case signalingStateHaveRemotePranswerStr:
+		return SignalingStateHaveRemotePranswer
+	case signalingStateClosedStr:
+		return SignalingStateClosed
+	default:
+		return SignalingState(Unknown)
+	}
+}
+
+func (t SignalingState) String() string {
+	switch t {
+	case SignalingStateStable:
+		return signalingStateStableStr
+	case SignalingStateHaveLocalOffer:
+		return signalingStateHaveLocalOfferStr
+	case SignalingStateHaveRemoteOffer:
+		return signalingStateHaveRemoteOfferStr
+	case SignalingStateHaveLocalPranswer:
+		return signalingStateHaveLocalPranswerStr
+	case SignalingStateHaveRemotePranswer:
+		return signalingStateHaveRemotePranswerStr
+	case SignalingStateClosed:
+		return signalingStateClosedStr
+	default:
+		return ErrUnknownType.Error()
+	}
+}
+
+// Get thread safe read value
+func (t *SignalingState) Get() SignalingState {
+	return SignalingState(atomic.LoadInt32((*int32)(t)))
+}
+
+// Set thread safe write value
+func (t *SignalingState) Set(state SignalingState) {
+	atomic.StoreInt32((*int32)(t), int32(state))
+}
+
+func checkNextSignalingState(cur, next SignalingState, op stateChangeOp, sdpType SDPType) (SignalingState, error) { // nolint:gocognit
+	// Special case for rollbacks
+	if sdpType == SDPTypeRollback && cur == SignalingStateStable {
+		return cur, &rtcerr.InvalidModificationError{
+			Err: errSignalingStateCannotRollback,
+		}
+	}
+
+	// 4.3.1 valid state transitions
+	switch cur { // nolint:exhaustive
+	case SignalingStateStable:
+		switch op {
+		case stateChangeOpSetLocal:
+			// stable->SetLocal(offer)->have-local-offer
+			if sdpType == SDPTypeOffer && next == SignalingStateHaveLocalOffer {
+				return next, nil
+			}
+		case stateChangeOpSetRemote:
+			// stable->SetRemote(offer)->have-remote-offer
+			if sdpType == SDPTypeOffer && next == SignalingStateHaveRemoteOffer {
+				return next, nil
+			}
+		}
+	case SignalingStateHaveLocalOffer:
+		if op == stateChangeOpSetRemote {
+			switch sdpType { // nolint:exhaustive
+			// have-local-offer->SetRemote(answer)->stable
+			case SDPTypeAnswer:
+				if next == SignalingStateStable {
+					return next, nil
+				}
+			// have-local-offer->SetRemote(pranswer)->have-remote-pranswer
+			case SDPTypePranswer:
+				if next == SignalingStateHaveRemotePranswer {
+					return next, nil
+				}
+			}
+		}
+	case SignalingStateHaveRemotePranswer:
+		if op == stateChangeOpSetRemote && sdpType == SDPTypeAnswer {
+			// have-remote-pranswer->SetRemote(answer)->stable
+			if next == SignalingStateStable {
+				return next, nil
+			}
+		}
+	case SignalingStateHaveRemoteOffer:
+		if op == stateChangeOpSetLocal {
+			switch sdpType { // nolint:exhaustive
+			// have-remote-offer->SetLocal(answer)->stable
+			case SDPTypeAnswer:
+				if next == SignalingStateStable {
+					return next, nil
+				}
+			// have-remote-offer->SetLocal(pranswer)->have-local-pranswer
+			case SDPTypePranswer:
+				if next == SignalingStateHaveLocalPranswer {
+					return next, nil
+				}
+			}
+		}
+	case SignalingStateHaveLocalPranswer:
+		if op == stateChangeOpSetLocal && sdpType == SDPTypeAnswer {
+			// have-local-pranswer->SetLocal(answer)->stable
+			if next == SignalingStateStable {
+				return next, nil
+			}
+		}
+	}
+	return cur, &rtcerr.InvalidModificationError{
+		Err: fmt.Errorf("%w: %s->%s(%s)->%s", errSignalingStateProposedTransitionInvalid, cur, op, sdpType, next),
+	}
+}