diff --git a/internal/rtmp/gen.go b/internal/rtmp/gen.go
new file mode 100644
index 000000000..cb997e5c7
--- /dev/null
+++ b/internal/rtmp/gen.go
@@ -0,0 +1,7 @@
+// Copyright (c) 2026 Winlin
+//
+// SPDX-License-Identifier: MIT
+package rtmp
+
+//go:generate go tool counterfeiter -o rtmpfakes/fake_handshake.go . Handshake
+//go:generate go tool counterfeiter -o rtmpfakes/fake_protocol.go . Protocol
diff --git a/internal/rtmp/rtmpfakes/fake_handshake.go b/internal/rtmp/rtmpfakes/fake_handshake.go
new file mode 100644
index 000000000..521800811
--- /dev/null
+++ b/internal/rtmp/rtmpfakes/fake_handshake.go
@@ -0,0 +1,554 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package rtmpfakes
+
+import (
+	"io"
+	"srsx/internal/rtmp"
+	"sync"
+)
+
+type FakeHandshake struct {
+	C1S1Stub        func() []byte
+	c1S1Mutex       sync.RWMutex
+	c1S1ArgsForCall []struct {
+	}
+	c1S1Returns struct {
+		result1 []byte
+	}
+	c1S1ReturnsOnCall map[int]struct {
+		result1 []byte
+	}
+	ReadC0S0Stub        func(io.Reader) ([]byte, error)
+	readC0S0Mutex       sync.RWMutex
+	readC0S0ArgsForCall []struct {
+		arg1 io.Reader
+	}
+	readC0S0Returns struct {
+		result1 []byte
+		result2 error
+	}
+	readC0S0ReturnsOnCall map[int]struct {
+		result1 []byte
+		result2 error
+	}
+	ReadC1S1Stub        func(io.Reader) ([]byte, error)
+	readC1S1Mutex       sync.RWMutex
+	readC1S1ArgsForCall []struct {
+		arg1 io.Reader
+	}
+	readC1S1Returns struct {
+		result1 []byte
+		result2 error
+	}
+	readC1S1ReturnsOnCall map[int]struct {
+		result1 []byte
+		result2 error
+	}
+	ReadC2S2Stub        func(io.Reader) ([]byte, error)
+	readC2S2Mutex       sync.RWMutex
+	readC2S2ArgsForCall []struct {
+		arg1 io.Reader
+	}
+	readC2S2Returns struct {
+		result1 []byte
+		result2 error
+	}
+	readC2S2ReturnsOnCall map[int]struct {
+		result1 []byte
+		result2 error
+	}
+	WriteC0S0Stub        func(io.Writer) error
+	writeC0S0Mutex       sync.RWMutex
+	writeC0S0ArgsForCall []struct {
+		arg1 io.Writer
+	}
+	writeC0S0Returns struct {
+		result1 error
+	}
+	writeC0S0ReturnsOnCall map[int]struct {
+		result1 error
+	}
+	WriteC1S1Stub        func(io.Writer) error
+	writeC1S1Mutex       sync.RWMutex
+	writeC1S1ArgsForCall []struct {
+		arg1 io.Writer
+	}
+	writeC1S1Returns struct {
+		result1 error
+	}
+	writeC1S1ReturnsOnCall map[int]struct {
+		result1 error
+	}
+	WriteC2S2Stub        func(io.Writer, []byte) error
+	writeC2S2Mutex       sync.RWMutex
+	writeC2S2ArgsForCall []struct {
+		arg1 io.Writer
+		arg2 []byte
+	}
+	writeC2S2Returns struct {
+		result1 error
+	}
+	writeC2S2ReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeHandshake) C1S1() []byte {
+	fake.c1S1Mutex.Lock()
+	ret, specificReturn := fake.c1S1ReturnsOnCall[len(fake.c1S1ArgsForCall)]
+	fake.c1S1ArgsForCall = append(fake.c1S1ArgsForCall, struct {
+	}{})
+	stub := fake.C1S1Stub
+	fakeReturns := fake.c1S1Returns
+	fake.recordInvocation("C1S1", []interface{}{})
+	fake.c1S1Mutex.Unlock()
+	if stub != nil {
+		return stub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeHandshake) C1S1CallCount() int {
+	fake.c1S1Mutex.RLock()
+	defer fake.c1S1Mutex.RUnlock()
+	return len(fake.c1S1ArgsForCall)
+}
+
+func (fake *FakeHandshake) C1S1Calls(stub func() []byte) {
+	fake.c1S1Mutex.Lock()
+	defer fake.c1S1Mutex.Unlock()
+	fake.C1S1Stub = stub
+}
+
+func (fake *FakeHandshake) C1S1Returns(result1 []byte) {
+	fake.c1S1Mutex.Lock()
+	defer fake.c1S1Mutex.Unlock()
+	fake.C1S1Stub = nil
+	fake.c1S1Returns = struct {
+		result1 []byte
+	}{result1}
+}
+
+func (fake *FakeHandshake) C1S1ReturnsOnCall(i int, result1 []byte) {
+	fake.c1S1Mutex.Lock()
+	defer fake.c1S1Mutex.Unlock()
+	fake.C1S1Stub = nil
+	if fake.c1S1ReturnsOnCall == nil {
+		fake.c1S1ReturnsOnCall = make(map[int]struct {
+			result1 []byte
+		})
+	}
+	fake.c1S1ReturnsOnCall[i] = struct {
+		result1 []byte
+	}{result1}
+}
+
+func (fake *FakeHandshake) ReadC0S0(arg1 io.Reader) ([]byte, error) {
+	fake.readC0S0Mutex.Lock()
+	ret, specificReturn := fake.readC0S0ReturnsOnCall[len(fake.readC0S0ArgsForCall)]
+	fake.readC0S0ArgsForCall = append(fake.readC0S0ArgsForCall, struct {
+		arg1 io.Reader
+	}{arg1})
+	stub := fake.ReadC0S0Stub
+	fakeReturns := fake.readC0S0Returns
+	fake.recordInvocation("ReadC0S0", []interface{}{arg1})
+	fake.readC0S0Mutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeHandshake) ReadC0S0CallCount() int {
+	fake.readC0S0Mutex.RLock()
+	defer fake.readC0S0Mutex.RUnlock()
+	return len(fake.readC0S0ArgsForCall)
+}
+
+func (fake *FakeHandshake) ReadC0S0Calls(stub func(io.Reader) ([]byte, error)) {
+	fake.readC0S0Mutex.Lock()
+	defer fake.readC0S0Mutex.Unlock()
+	fake.ReadC0S0Stub = stub
+}
+
+func (fake *FakeHandshake) ReadC0S0ArgsForCall(i int) io.Reader {
+	fake.readC0S0Mutex.RLock()
+	defer fake.readC0S0Mutex.RUnlock()
+	argsForCall := fake.readC0S0ArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeHandshake) ReadC0S0Returns(result1 []byte, result2 error) {
+	fake.readC0S0Mutex.Lock()
+	defer fake.readC0S0Mutex.Unlock()
+	fake.ReadC0S0Stub = nil
+	fake.readC0S0Returns = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeHandshake) ReadC0S0ReturnsOnCall(i int, result1 []byte, result2 error) {
+	fake.readC0S0Mutex.Lock()
+	defer fake.readC0S0Mutex.Unlock()
+	fake.ReadC0S0Stub = nil
+	if fake.readC0S0ReturnsOnCall == nil {
+		fake.readC0S0ReturnsOnCall = make(map[int]struct {
+			result1 []byte
+			result2 error
+		})
+	}
+	fake.readC0S0ReturnsOnCall[i] = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeHandshake) ReadC1S1(arg1 io.Reader) ([]byte, error) {
+	fake.readC1S1Mutex.Lock()
+	ret, specificReturn := fake.readC1S1ReturnsOnCall[len(fake.readC1S1ArgsForCall)]
+	fake.readC1S1ArgsForCall = append(fake.readC1S1ArgsForCall, struct {
+		arg1 io.Reader
+	}{arg1})
+	stub := fake.ReadC1S1Stub
+	fakeReturns := fake.readC1S1Returns
+	fake.recordInvocation("ReadC1S1", []interface{}{arg1})
+	fake.readC1S1Mutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeHandshake) ReadC1S1CallCount() int {
+	fake.readC1S1Mutex.RLock()
+	defer fake.readC1S1Mutex.RUnlock()
+	return len(fake.readC1S1ArgsForCall)
+}
+
+func (fake *FakeHandshake) ReadC1S1Calls(stub func(io.Reader) ([]byte, error)) {
+	fake.readC1S1Mutex.Lock()
+	defer fake.readC1S1Mutex.Unlock()
+	fake.ReadC1S1Stub = stub
+}
+
+func (fake *FakeHandshake) ReadC1S1ArgsForCall(i int) io.Reader {
+	fake.readC1S1Mutex.RLock()
+	defer fake.readC1S1Mutex.RUnlock()
+	argsForCall := fake.readC1S1ArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeHandshake) ReadC1S1Returns(result1 []byte, result2 error) {
+	fake.readC1S1Mutex.Lock()
+	defer fake.readC1S1Mutex.Unlock()
+	fake.ReadC1S1Stub = nil
+	fake.readC1S1Returns = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeHandshake) ReadC1S1ReturnsOnCall(i int, result1 []byte, result2 error) {
+	fake.readC1S1Mutex.Lock()
+	defer fake.readC1S1Mutex.Unlock()
+	fake.ReadC1S1Stub = nil
+	if fake.readC1S1ReturnsOnCall == nil {
+		fake.readC1S1ReturnsOnCall = make(map[int]struct {
+			result1 []byte
+			result2 error
+		})
+	}
+	fake.readC1S1ReturnsOnCall[i] = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeHandshake) ReadC2S2(arg1 io.Reader) ([]byte, error) {
+	fake.readC2S2Mutex.Lock()
+	ret, specificReturn := fake.readC2S2ReturnsOnCall[len(fake.readC2S2ArgsForCall)]
+	fake.readC2S2ArgsForCall = append(fake.readC2S2ArgsForCall, struct {
+		arg1 io.Reader
+	}{arg1})
+	stub := fake.ReadC2S2Stub
+	fakeReturns := fake.readC2S2Returns
+	fake.recordInvocation("ReadC2S2", []interface{}{arg1})
+	fake.readC2S2Mutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeHandshake) ReadC2S2CallCount() int {
+	fake.readC2S2Mutex.RLock()
+	defer fake.readC2S2Mutex.RUnlock()
+	return len(fake.readC2S2ArgsForCall)
+}
+
+func (fake *FakeHandshake) ReadC2S2Calls(stub func(io.Reader) ([]byte, error)) {
+	fake.readC2S2Mutex.Lock()
+	defer fake.readC2S2Mutex.Unlock()
+	fake.ReadC2S2Stub = stub
+}
+
+func (fake *FakeHandshake) ReadC2S2ArgsForCall(i int) io.Reader {
+	fake.readC2S2Mutex.RLock()
+	defer fake.readC2S2Mutex.RUnlock()
+	argsForCall := fake.readC2S2ArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeHandshake) ReadC2S2Returns(result1 []byte, result2 error) {
+	fake.readC2S2Mutex.Lock()
+	defer fake.readC2S2Mutex.Unlock()
+	fake.ReadC2S2Stub = nil
+	fake.readC2S2Returns = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeHandshake) ReadC2S2ReturnsOnCall(i int, result1 []byte, result2 error) {
+	fake.readC2S2Mutex.Lock()
+	defer fake.readC2S2Mutex.Unlock()
+	fake.ReadC2S2Stub = nil
+	if fake.readC2S2ReturnsOnCall == nil {
+		fake.readC2S2ReturnsOnCall = make(map[int]struct {
+			result1 []byte
+			result2 error
+		})
+	}
+	fake.readC2S2ReturnsOnCall[i] = struct {
+		result1 []byte
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeHandshake) WriteC0S0(arg1 io.Writer) error {
+	fake.writeC0S0Mutex.Lock()
+	ret, specificReturn := fake.writeC0S0ReturnsOnCall[len(fake.writeC0S0ArgsForCall)]
+	fake.writeC0S0ArgsForCall = append(fake.writeC0S0ArgsForCall, struct {
+		arg1 io.Writer
+	}{arg1})
+	stub := fake.WriteC0S0Stub
+	fakeReturns := fake.writeC0S0Returns
+	fake.recordInvocation("WriteC0S0", []interface{}{arg1})
+	fake.writeC0S0Mutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeHandshake) WriteC0S0CallCount() int {
+	fake.writeC0S0Mutex.RLock()
+	defer fake.writeC0S0Mutex.RUnlock()
+	return len(fake.writeC0S0ArgsForCall)
+}
+
+func (fake *FakeHandshake) WriteC0S0Calls(stub func(io.Writer) error) {
+	fake.writeC0S0Mutex.Lock()
+	defer fake.writeC0S0Mutex.Unlock()
+	fake.WriteC0S0Stub = stub
+}
+
+func (fake *FakeHandshake) WriteC0S0ArgsForCall(i int) io.Writer {
+	fake.writeC0S0Mutex.RLock()
+	defer fake.writeC0S0Mutex.RUnlock()
+	argsForCall := fake.writeC0S0ArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeHandshake) WriteC0S0Returns(result1 error) {
+	fake.writeC0S0Mutex.Lock()
+	defer fake.writeC0S0Mutex.Unlock()
+	fake.WriteC0S0Stub = nil
+	fake.writeC0S0Returns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeHandshake) WriteC0S0ReturnsOnCall(i int, result1 error) {
+	fake.writeC0S0Mutex.Lock()
+	defer fake.writeC0S0Mutex.Unlock()
+	fake.WriteC0S0Stub = nil
+	if fake.writeC0S0ReturnsOnCall == nil {
+		fake.writeC0S0ReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writeC0S0ReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeHandshake) WriteC1S1(arg1 io.Writer) error {
+	fake.writeC1S1Mutex.Lock()
+	ret, specificReturn := fake.writeC1S1ReturnsOnCall[len(fake.writeC1S1ArgsForCall)]
+	fake.writeC1S1ArgsForCall = append(fake.writeC1S1ArgsForCall, struct {
+		arg1 io.Writer
+	}{arg1})
+	stub := fake.WriteC1S1Stub
+	fakeReturns := fake.writeC1S1Returns
+	fake.recordInvocation("WriteC1S1", []interface{}{arg1})
+	fake.writeC1S1Mutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeHandshake) WriteC1S1CallCount() int {
+	fake.writeC1S1Mutex.RLock()
+	defer fake.writeC1S1Mutex.RUnlock()
+	return len(fake.writeC1S1ArgsForCall)
+}
+
+func (fake *FakeHandshake) WriteC1S1Calls(stub func(io.Writer) error) {
+	fake.writeC1S1Mutex.Lock()
+	defer fake.writeC1S1Mutex.Unlock()
+	fake.WriteC1S1Stub = stub
+}
+
+func (fake *FakeHandshake) WriteC1S1ArgsForCall(i int) io.Writer {
+	fake.writeC1S1Mutex.RLock()
+	defer fake.writeC1S1Mutex.RUnlock()
+	argsForCall := fake.writeC1S1ArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeHandshake) WriteC1S1Returns(result1 error) {
+	fake.writeC1S1Mutex.Lock()
+	defer fake.writeC1S1Mutex.Unlock()
+	fake.WriteC1S1Stub = nil
+	fake.writeC1S1Returns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeHandshake) WriteC1S1ReturnsOnCall(i int, result1 error) {
+	fake.writeC1S1Mutex.Lock()
+	defer fake.writeC1S1Mutex.Unlock()
+	fake.WriteC1S1Stub = nil
+	if fake.writeC1S1ReturnsOnCall == nil {
+		fake.writeC1S1ReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writeC1S1ReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeHandshake) WriteC2S2(arg1 io.Writer, arg2 []byte) error {
+	var arg2Copy []byte
+	if arg2 != nil {
+		arg2Copy = make([]byte, len(arg2))
+		copy(arg2Copy, arg2)
+	}
+	fake.writeC2S2Mutex.Lock()
+	ret, specificReturn := fake.writeC2S2ReturnsOnCall[len(fake.writeC2S2ArgsForCall)]
+	fake.writeC2S2ArgsForCall = append(fake.writeC2S2ArgsForCall, struct {
+		arg1 io.Writer
+		arg2 []byte
+	}{arg1, arg2Copy})
+	stub := fake.WriteC2S2Stub
+	fakeReturns := fake.writeC2S2Returns
+	fake.recordInvocation("WriteC2S2", []interface{}{arg1, arg2Copy})
+	fake.writeC2S2Mutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeHandshake) WriteC2S2CallCount() int {
+	fake.writeC2S2Mutex.RLock()
+	defer fake.writeC2S2Mutex.RUnlock()
+	return len(fake.writeC2S2ArgsForCall)
+}
+
+func (fake *FakeHandshake) WriteC2S2Calls(stub func(io.Writer, []byte) error) {
+	fake.writeC2S2Mutex.Lock()
+	defer fake.writeC2S2Mutex.Unlock()
+	fake.WriteC2S2Stub = stub
+}
+
+func (fake *FakeHandshake) WriteC2S2ArgsForCall(i int) (io.Writer, []byte) {
+	fake.writeC2S2Mutex.RLock()
+	defer fake.writeC2S2Mutex.RUnlock()
+	argsForCall := fake.writeC2S2ArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeHandshake) WriteC2S2Returns(result1 error) {
+	fake.writeC2S2Mutex.Lock()
+	defer fake.writeC2S2Mutex.Unlock()
+	fake.WriteC2S2Stub = nil
+	fake.writeC2S2Returns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeHandshake) WriteC2S2ReturnsOnCall(i int, result1 error) {
+	fake.writeC2S2Mutex.Lock()
+	defer fake.writeC2S2Mutex.Unlock()
+	fake.WriteC2S2Stub = nil
+	if fake.writeC2S2ReturnsOnCall == nil {
+		fake.writeC2S2ReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writeC2S2ReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeHandshake) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeHandshake) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ rtmp.Handshake = new(FakeHandshake)
diff --git a/internal/rtmp/rtmpfakes/fake_protocol.go b/internal/rtmp/rtmpfakes/fake_protocol.go
new file mode 100644
index 000000000..abbb5d3d3
--- /dev/null
+++ b/internal/rtmp/rtmpfakes/fake_protocol.go
@@ -0,0 +1,499 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package rtmpfakes
+
+import (
+	"context"
+	"srsx/internal/rtmp"
+	"sync"
+)
+
+type FakeProtocol struct {
+	DecodeMessageStub        func(rtmp.Message) (rtmp.Packet, error)
+	decodeMessageMutex       sync.RWMutex
+	decodeMessageArgsForCall []struct {
+		arg1 rtmp.Message
+	}
+	decodeMessageReturns struct {
+		result1 rtmp.Packet
+		result2 error
+	}
+	decodeMessageReturnsOnCall map[int]struct {
+		result1 rtmp.Packet
+		result2 error
+	}
+	ExpectMessageStub        func(context.Context, ...rtmp.MessageType) (rtmp.Message, error)
+	expectMessageMutex       sync.RWMutex
+	expectMessageArgsForCall []struct {
+		arg1 context.Context
+		arg2 []rtmp.MessageType
+	}
+	expectMessageReturns struct {
+		result1 rtmp.Message
+		result2 error
+	}
+	expectMessageReturnsOnCall map[int]struct {
+		result1 rtmp.Message
+		result2 error
+	}
+	ExpectPacketStub        func(context.Context, any) (rtmp.Message, error)
+	expectPacketMutex       sync.RWMutex
+	expectPacketArgsForCall []struct {
+		arg1 context.Context
+		arg2 any
+	}
+	expectPacketReturns struct {
+		result1 rtmp.Message
+		result2 error
+	}
+	expectPacketReturnsOnCall map[int]struct {
+		result1 rtmp.Message
+		result2 error
+	}
+	ReadMessageStub        func(context.Context) (rtmp.Message, error)
+	readMessageMutex       sync.RWMutex
+	readMessageArgsForCall []struct {
+		arg1 context.Context
+	}
+	readMessageReturns struct {
+		result1 rtmp.Message
+		result2 error
+	}
+	readMessageReturnsOnCall map[int]struct {
+		result1 rtmp.Message
+		result2 error
+	}
+	WriteMessageStub        func(context.Context, rtmp.Message) error
+	writeMessageMutex       sync.RWMutex
+	writeMessageArgsForCall []struct {
+		arg1 context.Context
+		arg2 rtmp.Message
+	}
+	writeMessageReturns struct {
+		result1 error
+	}
+	writeMessageReturnsOnCall map[int]struct {
+		result1 error
+	}
+	WritePacketStub        func(context.Context, rtmp.Packet, int) error
+	writePacketMutex       sync.RWMutex
+	writePacketArgsForCall []struct {
+		arg1 context.Context
+		arg2 rtmp.Packet
+		arg3 int
+	}
+	writePacketReturns struct {
+		result1 error
+	}
+	writePacketReturnsOnCall map[int]struct {
+		result1 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeProtocol) DecodeMessage(arg1 rtmp.Message) (rtmp.Packet, error) {
+	fake.decodeMessageMutex.Lock()
+	ret, specificReturn := fake.decodeMessageReturnsOnCall[len(fake.decodeMessageArgsForCall)]
+	fake.decodeMessageArgsForCall = append(fake.decodeMessageArgsForCall, struct {
+		arg1 rtmp.Message
+	}{arg1})
+	stub := fake.DecodeMessageStub
+	fakeReturns := fake.decodeMessageReturns
+	fake.recordInvocation("DecodeMessage", []interface{}{arg1})
+	fake.decodeMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeProtocol) DecodeMessageCallCount() int {
+	fake.decodeMessageMutex.RLock()
+	defer fake.decodeMessageMutex.RUnlock()
+	return len(fake.decodeMessageArgsForCall)
+}
+
+func (fake *FakeProtocol) DecodeMessageCalls(stub func(rtmp.Message) (rtmp.Packet, error)) {
+	fake.decodeMessageMutex.Lock()
+	defer fake.decodeMessageMutex.Unlock()
+	fake.DecodeMessageStub = stub
+}
+
+func (fake *FakeProtocol) DecodeMessageArgsForCall(i int) rtmp.Message {
+	fake.decodeMessageMutex.RLock()
+	defer fake.decodeMessageMutex.RUnlock()
+	argsForCall := fake.decodeMessageArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeProtocol) DecodeMessageReturns(result1 rtmp.Packet, result2 error) {
+	fake.decodeMessageMutex.Lock()
+	defer fake.decodeMessageMutex.Unlock()
+	fake.DecodeMessageStub = nil
+	fake.decodeMessageReturns = struct {
+		result1 rtmp.Packet
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) DecodeMessageReturnsOnCall(i int, result1 rtmp.Packet, result2 error) {
+	fake.decodeMessageMutex.Lock()
+	defer fake.decodeMessageMutex.Unlock()
+	fake.DecodeMessageStub = nil
+	if fake.decodeMessageReturnsOnCall == nil {
+		fake.decodeMessageReturnsOnCall = make(map[int]struct {
+			result1 rtmp.Packet
+			result2 error
+		})
+	}
+	fake.decodeMessageReturnsOnCall[i] = struct {
+		result1 rtmp.Packet
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) ExpectMessage(arg1 context.Context, arg2 ...rtmp.MessageType) (rtmp.Message, error) {
+	fake.expectMessageMutex.Lock()
+	ret, specificReturn := fake.expectMessageReturnsOnCall[len(fake.expectMessageArgsForCall)]
+	fake.expectMessageArgsForCall = append(fake.expectMessageArgsForCall, struct {
+		arg1 context.Context
+		arg2 []rtmp.MessageType
+	}{arg1, arg2})
+	stub := fake.ExpectMessageStub
+	fakeReturns := fake.expectMessageReturns
+	fake.recordInvocation("ExpectMessage", []interface{}{arg1, arg2})
+	fake.expectMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2...)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeProtocol) ExpectMessageCallCount() int {
+	fake.expectMessageMutex.RLock()
+	defer fake.expectMessageMutex.RUnlock()
+	return len(fake.expectMessageArgsForCall)
+}
+
+func (fake *FakeProtocol) ExpectMessageCalls(stub func(context.Context, ...rtmp.MessageType) (rtmp.Message, error)) {
+	fake.expectMessageMutex.Lock()
+	defer fake.expectMessageMutex.Unlock()
+	fake.ExpectMessageStub = stub
+}
+
+func (fake *FakeProtocol) ExpectMessageArgsForCall(i int) (context.Context, []rtmp.MessageType) {
+	fake.expectMessageMutex.RLock()
+	defer fake.expectMessageMutex.RUnlock()
+	argsForCall := fake.expectMessageArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeProtocol) ExpectMessageReturns(result1 rtmp.Message, result2 error) {
+	fake.expectMessageMutex.Lock()
+	defer fake.expectMessageMutex.Unlock()
+	fake.ExpectMessageStub = nil
+	fake.expectMessageReturns = struct {
+		result1 rtmp.Message
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) ExpectMessageReturnsOnCall(i int, result1 rtmp.Message, result2 error) {
+	fake.expectMessageMutex.Lock()
+	defer fake.expectMessageMutex.Unlock()
+	fake.ExpectMessageStub = nil
+	if fake.expectMessageReturnsOnCall == nil {
+		fake.expectMessageReturnsOnCall = make(map[int]struct {
+			result1 rtmp.Message
+			result2 error
+		})
+	}
+	fake.expectMessageReturnsOnCall[i] = struct {
+		result1 rtmp.Message
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) ExpectPacket(arg1 context.Context, arg2 any) (rtmp.Message, error) {
+	fake.expectPacketMutex.Lock()
+	ret, specificReturn := fake.expectPacketReturnsOnCall[len(fake.expectPacketArgsForCall)]
+	fake.expectPacketArgsForCall = append(fake.expectPacketArgsForCall, struct {
+		arg1 context.Context
+		arg2 any
+	}{arg1, arg2})
+	stub := fake.ExpectPacketStub
+	fakeReturns := fake.expectPacketReturns
+	fake.recordInvocation("ExpectPacket", []interface{}{arg1, arg2})
+	fake.expectPacketMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeProtocol) ExpectPacketCallCount() int {
+	fake.expectPacketMutex.RLock()
+	defer fake.expectPacketMutex.RUnlock()
+	return len(fake.expectPacketArgsForCall)
+}
+
+func (fake *FakeProtocol) ExpectPacketCalls(stub func(context.Context, any) (rtmp.Message, error)) {
+	fake.expectPacketMutex.Lock()
+	defer fake.expectPacketMutex.Unlock()
+	fake.ExpectPacketStub = stub
+}
+
+func (fake *FakeProtocol) ExpectPacketArgsForCall(i int) (context.Context, any) {
+	fake.expectPacketMutex.RLock()
+	defer fake.expectPacketMutex.RUnlock()
+	argsForCall := fake.expectPacketArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeProtocol) ExpectPacketReturns(result1 rtmp.Message, result2 error) {
+	fake.expectPacketMutex.Lock()
+	defer fake.expectPacketMutex.Unlock()
+	fake.ExpectPacketStub = nil
+	fake.expectPacketReturns = struct {
+		result1 rtmp.Message
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) ExpectPacketReturnsOnCall(i int, result1 rtmp.Message, result2 error) {
+	fake.expectPacketMutex.Lock()
+	defer fake.expectPacketMutex.Unlock()
+	fake.ExpectPacketStub = nil
+	if fake.expectPacketReturnsOnCall == nil {
+		fake.expectPacketReturnsOnCall = make(map[int]struct {
+			result1 rtmp.Message
+			result2 error
+		})
+	}
+	fake.expectPacketReturnsOnCall[i] = struct {
+		result1 rtmp.Message
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) ReadMessage(arg1 context.Context) (rtmp.Message, error) {
+	fake.readMessageMutex.Lock()
+	ret, specificReturn := fake.readMessageReturnsOnCall[len(fake.readMessageArgsForCall)]
+	fake.readMessageArgsForCall = append(fake.readMessageArgsForCall, struct {
+		arg1 context.Context
+	}{arg1})
+	stub := fake.ReadMessageStub
+	fakeReturns := fake.readMessageReturns
+	fake.recordInvocation("ReadMessage", []interface{}{arg1})
+	fake.readMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeProtocol) ReadMessageCallCount() int {
+	fake.readMessageMutex.RLock()
+	defer fake.readMessageMutex.RUnlock()
+	return len(fake.readMessageArgsForCall)
+}
+
+func (fake *FakeProtocol) ReadMessageCalls(stub func(context.Context) (rtmp.Message, error)) {
+	fake.readMessageMutex.Lock()
+	defer fake.readMessageMutex.Unlock()
+	fake.ReadMessageStub = stub
+}
+
+func (fake *FakeProtocol) ReadMessageArgsForCall(i int) context.Context {
+	fake.readMessageMutex.RLock()
+	defer fake.readMessageMutex.RUnlock()
+	argsForCall := fake.readMessageArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeProtocol) ReadMessageReturns(result1 rtmp.Message, result2 error) {
+	fake.readMessageMutex.Lock()
+	defer fake.readMessageMutex.Unlock()
+	fake.ReadMessageStub = nil
+	fake.readMessageReturns = struct {
+		result1 rtmp.Message
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) ReadMessageReturnsOnCall(i int, result1 rtmp.Message, result2 error) {
+	fake.readMessageMutex.Lock()
+	defer fake.readMessageMutex.Unlock()
+	fake.ReadMessageStub = nil
+	if fake.readMessageReturnsOnCall == nil {
+		fake.readMessageReturnsOnCall = make(map[int]struct {
+			result1 rtmp.Message
+			result2 error
+		})
+	}
+	fake.readMessageReturnsOnCall[i] = struct {
+		result1 rtmp.Message
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeProtocol) WriteMessage(arg1 context.Context, arg2 rtmp.Message) error {
+	fake.writeMessageMutex.Lock()
+	ret, specificReturn := fake.writeMessageReturnsOnCall[len(fake.writeMessageArgsForCall)]
+	fake.writeMessageArgsForCall = append(fake.writeMessageArgsForCall, struct {
+		arg1 context.Context
+		arg2 rtmp.Message
+	}{arg1, arg2})
+	stub := fake.WriteMessageStub
+	fakeReturns := fake.writeMessageReturns
+	fake.recordInvocation("WriteMessage", []interface{}{arg1, arg2})
+	fake.writeMessageMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeProtocol) WriteMessageCallCount() int {
+	fake.writeMessageMutex.RLock()
+	defer fake.writeMessageMutex.RUnlock()
+	return len(fake.writeMessageArgsForCall)
+}
+
+func (fake *FakeProtocol) WriteMessageCalls(stub func(context.Context, rtmp.Message) error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = stub
+}
+
+func (fake *FakeProtocol) WriteMessageArgsForCall(i int) (context.Context, rtmp.Message) {
+	fake.writeMessageMutex.RLock()
+	defer fake.writeMessageMutex.RUnlock()
+	argsForCall := fake.writeMessageArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *FakeProtocol) WriteMessageReturns(result1 error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = nil
+	fake.writeMessageReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeProtocol) WriteMessageReturnsOnCall(i int, result1 error) {
+	fake.writeMessageMutex.Lock()
+	defer fake.writeMessageMutex.Unlock()
+	fake.WriteMessageStub = nil
+	if fake.writeMessageReturnsOnCall == nil {
+		fake.writeMessageReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writeMessageReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeProtocol) WritePacket(arg1 context.Context, arg2 rtmp.Packet, arg3 int) error {
+	fake.writePacketMutex.Lock()
+	ret, specificReturn := fake.writePacketReturnsOnCall[len(fake.writePacketArgsForCall)]
+	fake.writePacketArgsForCall = append(fake.writePacketArgsForCall, struct {
+		arg1 context.Context
+		arg2 rtmp.Packet
+		arg3 int
+	}{arg1, arg2, arg3})
+	stub := fake.WritePacketStub
+	fakeReturns := fake.writePacketReturns
+	fake.recordInvocation("WritePacket", []interface{}{arg1, arg2, arg3})
+	fake.writePacketMutex.Unlock()
+	if stub != nil {
+		return stub(arg1, arg2, arg3)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	return fakeReturns.result1
+}
+
+func (fake *FakeProtocol) WritePacketCallCount() int {
+	fake.writePacketMutex.RLock()
+	defer fake.writePacketMutex.RUnlock()
+	return len(fake.writePacketArgsForCall)
+}
+
+func (fake *FakeProtocol) WritePacketCalls(stub func(context.Context, rtmp.Packet, int) error) {
+	fake.writePacketMutex.Lock()
+	defer fake.writePacketMutex.Unlock()
+	fake.WritePacketStub = stub
+}
+
+func (fake *FakeProtocol) WritePacketArgsForCall(i int) (context.Context, rtmp.Packet, int) {
+	fake.writePacketMutex.RLock()
+	defer fake.writePacketMutex.RUnlock()
+	argsForCall := fake.writePacketArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
+}
+
+func (fake *FakeProtocol) WritePacketReturns(result1 error) {
+	fake.writePacketMutex.Lock()
+	defer fake.writePacketMutex.Unlock()
+	fake.WritePacketStub = nil
+	fake.writePacketReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeProtocol) WritePacketReturnsOnCall(i int, result1 error) {
+	fake.writePacketMutex.Lock()
+	defer fake.writePacketMutex.Unlock()
+	fake.WritePacketStub = nil
+	if fake.writePacketReturnsOnCall == nil {
+		fake.writePacketReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.writePacketReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *FakeProtocol) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeProtocol) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ rtmp.Protocol = new(FakeProtocol)