// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: app/service/live/rtc/api/v1/api.proto

package v1

/*
	package 命名使用 {discovery_id}.{version} 的方式, version 形如 v1, v2, v1beta ..
	NOTE: 不知道的 discovery_id 请询问大佬, 新项目找大佬申请 discovery_id，先到先得抢注
	e.g. account.service.v1
*/

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type MediaSource_MediaType int32

const (
	MediaSource_OTHER       MediaSource_MediaType = 0
	MediaSource_VIDEO       MediaSource_MediaType = 1
	MediaSource_AUDIO       MediaSource_MediaType = 2
	MediaSource_DATA        MediaSource_MediaType = 3
	MediaSource_SMALL_VIDEO MediaSource_MediaType = 4
)

var MediaSource_MediaType_name = map[int32]string{
	0: "OTHER",
	1: "VIDEO",
	2: "AUDIO",
	3: "DATA",
	4: "SMALL_VIDEO",
}
var MediaSource_MediaType_value = map[string]int32{
	"OTHER":       0,
	"VIDEO":       1,
	"AUDIO":       2,
	"DATA":        3,
	"SMALL_VIDEO": 4,
}

func (x MediaSource_MediaType) String() string {
	return proto.EnumName(MediaSource_MediaType_name, int32(x))
}
func (MediaSource_MediaType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{0, 0}
}

type MediaSource struct {
	Type                 MediaSource_MediaType `protobuf:"varint,1,opt,name=type,proto3,enum=live.rtc.v1.MediaSource_MediaType" json:"type"`
	Codec                string                `protobuf:"bytes,2,opt,name=codec,proto3" json:"codec"`
	MediaSpecific        string                `protobuf:"bytes,3,opt,name=media_specific,json=mediaSpecific,proto3" json:"media_specific"`
	Ssrc                 uint32                `protobuf:"varint,4,opt,name=ssrc,proto3" json:"ssrc"`
	UserId               uint64                `protobuf:"varint,5,opt,name=user_id,json=userId,proto3" json:"user_id"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *MediaSource) Reset()         { *m = MediaSource{} }
func (m *MediaSource) String() string { return proto.CompactTextString(m) }
func (*MediaSource) ProtoMessage()    {}
func (*MediaSource) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{0}
}
func (m *MediaSource) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MediaSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MediaSource.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *MediaSource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MediaSource.Merge(dst, src)
}
func (m *MediaSource) XXX_Size() int {
	return m.Size()
}
func (m *MediaSource) XXX_DiscardUnknown() {
	xxx_messageInfo_MediaSource.DiscardUnknown(m)
}

var xxx_messageInfo_MediaSource proto.InternalMessageInfo

func (m *MediaSource) GetType() MediaSource_MediaType {
	if m != nil {
		return m.Type
	}
	return MediaSource_OTHER
}

func (m *MediaSource) GetCodec() string {
	if m != nil {
		return m.Codec
	}
	return ""
}

func (m *MediaSource) GetMediaSpecific() string {
	if m != nil {
		return m.MediaSpecific
	}
	return ""
}

func (m *MediaSource) GetSsrc() uint32 {
	if m != nil {
		return m.Ssrc
	}
	return 0
}

func (m *MediaSource) GetUserId() uint64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

type EncoderConfig struct {
	Width                uint32   `protobuf:"varint,1,opt,name=width,proto3" json:"width"`
	Height               uint32   `protobuf:"varint,2,opt,name=height,proto3" json:"height"`
	Bitrate              uint32   `protobuf:"varint,3,opt,name=bitrate,proto3" json:"bitrate"`
	FrameRate            uint32   `protobuf:"varint,4,opt,name=frame_rate,json=frameRate,proto3" json:"frame_rate"`
	VideoCodec           string   `protobuf:"bytes,5,opt,name=video_codec,json=videoCodec,proto3" json:"video_codec"`
	VideoProfile         string   `protobuf:"bytes,6,opt,name=video_profile,json=videoProfile,proto3" json:"video_profile"`
	Channel              uint32   `protobuf:"varint,19,opt,name=channel,proto3" json:"channel"`
	SampleRate           uint32   `protobuf:"varint,20,opt,name=sample_rate,json=sampleRate,proto3" json:"sample_rate"`
	AudioCodec           string   `protobuf:"bytes,21,opt,name=audio_codec,json=audioCodec,proto3" json:"audio_codec"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *EncoderConfig) Reset()         { *m = EncoderConfig{} }
func (m *EncoderConfig) String() string { return proto.CompactTextString(m) }
func (*EncoderConfig) ProtoMessage()    {}
func (*EncoderConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{1}
}
func (m *EncoderConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EncoderConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EncoderConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *EncoderConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EncoderConfig.Merge(dst, src)
}
func (m *EncoderConfig) XXX_Size() int {
	return m.Size()
}
func (m *EncoderConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_EncoderConfig.DiscardUnknown(m)
}

var xxx_messageInfo_EncoderConfig proto.InternalMessageInfo

func (m *EncoderConfig) GetWidth() uint32 {
	if m != nil {
		return m.Width
	}
	return 0
}

func (m *EncoderConfig) GetHeight() uint32 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *EncoderConfig) GetBitrate() uint32 {
	if m != nil {
		return m.Bitrate
	}
	return 0
}

func (m *EncoderConfig) GetFrameRate() uint32 {
	if m != nil {
		return m.FrameRate
	}
	return 0
}

func (m *EncoderConfig) GetVideoCodec() string {
	if m != nil {
		return m.VideoCodec
	}
	return ""
}

func (m *EncoderConfig) GetVideoProfile() string {
	if m != nil {
		return m.VideoProfile
	}
	return ""
}

func (m *EncoderConfig) GetChannel() uint32 {
	if m != nil {
		return m.Channel
	}
	return 0
}

func (m *EncoderConfig) GetSampleRate() uint32 {
	if m != nil {
		return m.SampleRate
	}
	return 0
}

func (m *EncoderConfig) GetAudioCodec() string {
	if m != nil {
		return m.AudioCodec
	}
	return ""
}

type JoinChannelRequest struct {
	ChannelId            uint64         `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	UserId               uint64         `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id"`
	ProtoVersion         uint32         `protobuf:"varint,3,opt,name=proto_version,json=protoVersion,proto3" json:"proto_version"`
	Source               []*MediaSource `protobuf:"bytes,4,rep,name=source" json:"source"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *JoinChannelRequest) Reset()         { *m = JoinChannelRequest{} }
func (m *JoinChannelRequest) String() string { return proto.CompactTextString(m) }
func (*JoinChannelRequest) ProtoMessage()    {}
func (*JoinChannelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{2}
}
func (m *JoinChannelRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JoinChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JoinChannelRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *JoinChannelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JoinChannelRequest.Merge(dst, src)
}
func (m *JoinChannelRequest) XXX_Size() int {
	return m.Size()
}
func (m *JoinChannelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_JoinChannelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_JoinChannelRequest proto.InternalMessageInfo

func (m *JoinChannelRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *JoinChannelRequest) GetUserId() uint64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *JoinChannelRequest) GetProtoVersion() uint32 {
	if m != nil {
		return m.ProtoVersion
	}
	return 0
}

func (m *JoinChannelRequest) GetSource() []*MediaSource {
	if m != nil {
		return m.Source
	}
	return nil
}

type JoinChannelResponse struct {
	CallId               uint32         `protobuf:"varint,1,opt,name=call_id,json=callId,proto3" json:"call_id"`
	Token                string         `protobuf:"bytes,2,opt,name=token,proto3" json:"token"`
	Source               []*MediaSource `protobuf:"bytes,3,rep,name=source" json:"source"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *JoinChannelResponse) Reset()         { *m = JoinChannelResponse{} }
func (m *JoinChannelResponse) String() string { return proto.CompactTextString(m) }
func (*JoinChannelResponse) ProtoMessage()    {}
func (*JoinChannelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{3}
}
func (m *JoinChannelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JoinChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JoinChannelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *JoinChannelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JoinChannelResponse.Merge(dst, src)
}
func (m *JoinChannelResponse) XXX_Size() int {
	return m.Size()
}
func (m *JoinChannelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_JoinChannelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_JoinChannelResponse proto.InternalMessageInfo

func (m *JoinChannelResponse) GetCallId() uint32 {
	if m != nil {
		return m.CallId
	}
	return 0
}

func (m *JoinChannelResponse) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *JoinChannelResponse) GetSource() []*MediaSource {
	if m != nil {
		return m.Source
	}
	return nil
}

type LeaveChannelRequest struct {
	ChannelId            uint64   `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	UserId               uint64   `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id"`
	CallId               uint32   `protobuf:"varint,3,opt,name=call_id,json=callId,proto3" json:"call_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LeaveChannelRequest) Reset()         { *m = LeaveChannelRequest{} }
func (m *LeaveChannelRequest) String() string { return proto.CompactTextString(m) }
func (*LeaveChannelRequest) ProtoMessage()    {}
func (*LeaveChannelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{4}
}
func (m *LeaveChannelRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LeaveChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LeaveChannelRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *LeaveChannelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LeaveChannelRequest.Merge(dst, src)
}
func (m *LeaveChannelRequest) XXX_Size() int {
	return m.Size()
}
func (m *LeaveChannelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LeaveChannelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LeaveChannelRequest proto.InternalMessageInfo

func (m *LeaveChannelRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *LeaveChannelRequest) GetUserId() uint64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *LeaveChannelRequest) GetCallId() uint32 {
	if m != nil {
		return m.CallId
	}
	return 0
}

type LeaveChannelResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LeaveChannelResponse) Reset()         { *m = LeaveChannelResponse{} }
func (m *LeaveChannelResponse) String() string { return proto.CompactTextString(m) }
func (*LeaveChannelResponse) ProtoMessage()    {}
func (*LeaveChannelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{5}
}
func (m *LeaveChannelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LeaveChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LeaveChannelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *LeaveChannelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LeaveChannelResponse.Merge(dst, src)
}
func (m *LeaveChannelResponse) XXX_Size() int {
	return m.Size()
}
func (m *LeaveChannelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LeaveChannelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LeaveChannelResponse proto.InternalMessageInfo

type PublishStreamRequest struct {
	ChannelId            uint64         `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	UserId               uint64         `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id"`
	CallId               uint32         `protobuf:"varint,3,opt,name=call_id,json=callId,proto3" json:"call_id"`
	EncoderConfig        *EncoderConfig `protobuf:"bytes,4,opt,name=encoder_config,json=encoderConfig" json:"encoder_config"`
	MixConfig            string         `protobuf:"bytes,5,opt,name=mix_config,json=mixConfig,proto3" json:"mix_config"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *PublishStreamRequest) Reset()         { *m = PublishStreamRequest{} }
func (m *PublishStreamRequest) String() string { return proto.CompactTextString(m) }
func (*PublishStreamRequest) ProtoMessage()    {}
func (*PublishStreamRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{6}
}
func (m *PublishStreamRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PublishStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PublishStreamRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *PublishStreamRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishStreamRequest.Merge(dst, src)
}
func (m *PublishStreamRequest) XXX_Size() int {
	return m.Size()
}
func (m *PublishStreamRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishStreamRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PublishStreamRequest proto.InternalMessageInfo

func (m *PublishStreamRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *PublishStreamRequest) GetUserId() uint64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *PublishStreamRequest) GetCallId() uint32 {
	if m != nil {
		return m.CallId
	}
	return 0
}

func (m *PublishStreamRequest) GetEncoderConfig() *EncoderConfig {
	if m != nil {
		return m.EncoderConfig
	}
	return nil
}

func (m *PublishStreamRequest) GetMixConfig() string {
	if m != nil {
		return m.MixConfig
	}
	return ""
}

type PublishStreamResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublishStreamResponse) Reset()         { *m = PublishStreamResponse{} }
func (m *PublishStreamResponse) String() string { return proto.CompactTextString(m) }
func (*PublishStreamResponse) ProtoMessage()    {}
func (*PublishStreamResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{7}
}
func (m *PublishStreamResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PublishStreamResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PublishStreamResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *PublishStreamResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishStreamResponse.Merge(dst, src)
}
func (m *PublishStreamResponse) XXX_Size() int {
	return m.Size()
}
func (m *PublishStreamResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishStreamResponse.DiscardUnknown(m)
}

var xxx_messageInfo_PublishStreamResponse proto.InternalMessageInfo

type TerminateStreamRequest struct {
	ChannelId            uint64   `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	UserId               uint64   `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id"`
	CallId               uint32   `protobuf:"varint,3,opt,name=call_id,json=callId,proto3" json:"call_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TerminateStreamRequest) Reset()         { *m = TerminateStreamRequest{} }
func (m *TerminateStreamRequest) String() string { return proto.CompactTextString(m) }
func (*TerminateStreamRequest) ProtoMessage()    {}
func (*TerminateStreamRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{8}
}
func (m *TerminateStreamRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TerminateStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TerminateStreamRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *TerminateStreamRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TerminateStreamRequest.Merge(dst, src)
}
func (m *TerminateStreamRequest) XXX_Size() int {
	return m.Size()
}
func (m *TerminateStreamRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TerminateStreamRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TerminateStreamRequest proto.InternalMessageInfo

func (m *TerminateStreamRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *TerminateStreamRequest) GetUserId() uint64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *TerminateStreamRequest) GetCallId() uint32 {
	if m != nil {
		return m.CallId
	}
	return 0
}

type TerminateStreamResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TerminateStreamResponse) Reset()         { *m = TerminateStreamResponse{} }
func (m *TerminateStreamResponse) String() string { return proto.CompactTextString(m) }
func (*TerminateStreamResponse) ProtoMessage()    {}
func (*TerminateStreamResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{9}
}
func (m *TerminateStreamResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TerminateStreamResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TerminateStreamResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *TerminateStreamResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TerminateStreamResponse.Merge(dst, src)
}
func (m *TerminateStreamResponse) XXX_Size() int {
	return m.Size()
}
func (m *TerminateStreamResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TerminateStreamResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TerminateStreamResponse proto.InternalMessageInfo

type ChannelRequest struct {
	ChannelId            uint64   `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ChannelRequest) Reset()         { *m = ChannelRequest{} }
func (m *ChannelRequest) String() string { return proto.CompactTextString(m) }
func (*ChannelRequest) ProtoMessage()    {}
func (*ChannelRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{10}
}
func (m *ChannelRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChannelRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChannelRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *ChannelRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelRequest.Merge(dst, src)
}
func (m *ChannelRequest) XXX_Size() int {
	return m.Size()
}
func (m *ChannelRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelRequest proto.InternalMessageInfo

func (m *ChannelRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

type ChannelResponse struct {
	MediaSource          []*MediaSource `protobuf:"bytes,1,rep,name=media_source,json=mediaSource" json:"media_source"`
	Server               string         `protobuf:"bytes,2,opt,name=server,proto3" json:"server"`
	TcpPort              uint32         `protobuf:"varint,3,opt,name=tcp_port,json=tcpPort,proto3" json:"tcp_port"`
	UdpPort              uint32         `protobuf:"varint,4,opt,name=udp_port,json=udpPort,proto3" json:"udp_port"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *ChannelResponse) Reset()         { *m = ChannelResponse{} }
func (m *ChannelResponse) String() string { return proto.CompactTextString(m) }
func (*ChannelResponse) ProtoMessage()    {}
func (*ChannelResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{11}
}
func (m *ChannelResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChannelResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChannelResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *ChannelResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChannelResponse.Merge(dst, src)
}
func (m *ChannelResponse) XXX_Size() int {
	return m.Size()
}
func (m *ChannelResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ChannelResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ChannelResponse proto.InternalMessageInfo

func (m *ChannelResponse) GetMediaSource() []*MediaSource {
	if m != nil {
		return m.MediaSource
	}
	return nil
}

func (m *ChannelResponse) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

func (m *ChannelResponse) GetTcpPort() uint32 {
	if m != nil {
		return m.TcpPort
	}
	return 0
}

func (m *ChannelResponse) GetUdpPort() uint32 {
	if m != nil {
		return m.UdpPort
	}
	return 0
}

type StreamRequest struct {
	ChannelId            uint64   `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	UserId               uint64   `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id"`
	CallId               uint32   `protobuf:"varint,3,opt,name=call_id,json=callId,proto3" json:"call_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamRequest) Reset()         { *m = StreamRequest{} }
func (m *StreamRequest) String() string { return proto.CompactTextString(m) }
func (*StreamRequest) ProtoMessage()    {}
func (*StreamRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{12}
}
func (m *StreamRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *StreamRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamRequest.Merge(dst, src)
}
func (m *StreamRequest) XXX_Size() int {
	return m.Size()
}
func (m *StreamRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StreamRequest proto.InternalMessageInfo

func (m *StreamRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *StreamRequest) GetUserId() uint64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *StreamRequest) GetCallId() uint32 {
	if m != nil {
		return m.CallId
	}
	return 0
}

type StreamResponse struct {
	EncoderConfig        *EncoderConfig `protobuf:"bytes,1,opt,name=encoder_config,json=encoderConfig" json:"encoder_config"`
	MixConfig            string         `protobuf:"bytes,2,opt,name=mix_config,json=mixConfig,proto3" json:"mix_config"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *StreamResponse) Reset()         { *m = StreamResponse{} }
func (m *StreamResponse) String() string { return proto.CompactTextString(m) }
func (*StreamResponse) ProtoMessage()    {}
func (*StreamResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{13}
}
func (m *StreamResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *StreamResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamResponse.Merge(dst, src)
}
func (m *StreamResponse) XXX_Size() int {
	return m.Size()
}
func (m *StreamResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StreamResponse proto.InternalMessageInfo

func (m *StreamResponse) GetEncoderConfig() *EncoderConfig {
	if m != nil {
		return m.EncoderConfig
	}
	return nil
}

func (m *StreamResponse) GetMixConfig() string {
	if m != nil {
		return m.MixConfig
	}
	return ""
}

type SetRtcConfigRequest struct {
	ChannelId            uint64   `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	UserId               uint64   `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id"`
	CallId               uint32   `protobuf:"varint,3,opt,name=call_id,json=callId,proto3" json:"call_id"`
	Config               string   `protobuf:"bytes,4,opt,name=config,proto3" json:"config"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetRtcConfigRequest) Reset()         { *m = SetRtcConfigRequest{} }
func (m *SetRtcConfigRequest) String() string { return proto.CompactTextString(m) }
func (*SetRtcConfigRequest) ProtoMessage()    {}
func (*SetRtcConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{14}
}
func (m *SetRtcConfigRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetRtcConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetRtcConfigRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *SetRtcConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetRtcConfigRequest.Merge(dst, src)
}
func (m *SetRtcConfigRequest) XXX_Size() int {
	return m.Size()
}
func (m *SetRtcConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetRtcConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetRtcConfigRequest proto.InternalMessageInfo

func (m *SetRtcConfigRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *SetRtcConfigRequest) GetUserId() uint64 {
	if m != nil {
		return m.UserId
	}
	return 0
}

func (m *SetRtcConfigRequest) GetCallId() uint32 {
	if m != nil {
		return m.CallId
	}
	return 0
}

func (m *SetRtcConfigRequest) GetConfig() string {
	if m != nil {
		return m.Config
	}
	return ""
}

type SetRtcConfigResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetRtcConfigResponse) Reset()         { *m = SetRtcConfigResponse{} }
func (m *SetRtcConfigResponse) String() string { return proto.CompactTextString(m) }
func (*SetRtcConfigResponse) ProtoMessage()    {}
func (*SetRtcConfigResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{15}
}
func (m *SetRtcConfigResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SetRtcConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SetRtcConfigResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *SetRtcConfigResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetRtcConfigResponse.Merge(dst, src)
}
func (m *SetRtcConfigResponse) XXX_Size() int {
	return m.Size()
}
func (m *SetRtcConfigResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SetRtcConfigResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SetRtcConfigResponse proto.InternalMessageInfo

type VerifyTokenRequest struct {
	ChannelId            uint64   `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id"`
	CallId               uint32   `protobuf:"varint,2,opt,name=call_id,json=callId,proto3" json:"call_id"`
	Token                string   `protobuf:"bytes,3,opt,name=token,proto3" json:"token"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VerifyTokenRequest) Reset()         { *m = VerifyTokenRequest{} }
func (m *VerifyTokenRequest) String() string { return proto.CompactTextString(m) }
func (*VerifyTokenRequest) ProtoMessage()    {}
func (*VerifyTokenRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{16}
}
func (m *VerifyTokenRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VerifyTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VerifyTokenRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *VerifyTokenRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyTokenRequest.Merge(dst, src)
}
func (m *VerifyTokenRequest) XXX_Size() int {
	return m.Size()
}
func (m *VerifyTokenRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyTokenRequest.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyTokenRequest proto.InternalMessageInfo

func (m *VerifyTokenRequest) GetChannelId() uint64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *VerifyTokenRequest) GetCallId() uint32 {
	if m != nil {
		return m.CallId
	}
	return 0
}

func (m *VerifyTokenRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

type VerifyTokenResponse struct {
	Pass                 bool     `protobuf:"varint,1,opt,name=pass,proto3" json:"pass"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VerifyTokenResponse) Reset()         { *m = VerifyTokenResponse{} }
func (m *VerifyTokenResponse) String() string { return proto.CompactTextString(m) }
func (*VerifyTokenResponse) ProtoMessage()    {}
func (*VerifyTokenResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_api_cc75e2c1742b635b, []int{17}
}
func (m *VerifyTokenResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VerifyTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VerifyTokenResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *VerifyTokenResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VerifyTokenResponse.Merge(dst, src)
}
func (m *VerifyTokenResponse) XXX_Size() int {
	return m.Size()
}
func (m *VerifyTokenResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_VerifyTokenResponse.DiscardUnknown(m)
}

var xxx_messageInfo_VerifyTokenResponse proto.InternalMessageInfo

func (m *VerifyTokenResponse) GetPass() bool {
	if m != nil {
		return m.Pass
	}
	return false
}

func init() {
	proto.RegisterType((*MediaSource)(nil), "live.rtc.v1.MediaSource")
	proto.RegisterType((*EncoderConfig)(nil), "live.rtc.v1.EncoderConfig")
	proto.RegisterType((*JoinChannelRequest)(nil), "live.rtc.v1.JoinChannelRequest")
	proto.RegisterType((*JoinChannelResponse)(nil), "live.rtc.v1.JoinChannelResponse")
	proto.RegisterType((*LeaveChannelRequest)(nil), "live.rtc.v1.LeaveChannelRequest")
	proto.RegisterType((*LeaveChannelResponse)(nil), "live.rtc.v1.LeaveChannelResponse")
	proto.RegisterType((*PublishStreamRequest)(nil), "live.rtc.v1.PublishStreamRequest")
	proto.RegisterType((*PublishStreamResponse)(nil), "live.rtc.v1.PublishStreamResponse")
	proto.RegisterType((*TerminateStreamRequest)(nil), "live.rtc.v1.TerminateStreamRequest")
	proto.RegisterType((*TerminateStreamResponse)(nil), "live.rtc.v1.TerminateStreamResponse")
	proto.RegisterType((*ChannelRequest)(nil), "live.rtc.v1.ChannelRequest")
	proto.RegisterType((*ChannelResponse)(nil), "live.rtc.v1.ChannelResponse")
	proto.RegisterType((*StreamRequest)(nil), "live.rtc.v1.StreamRequest")
	proto.RegisterType((*StreamResponse)(nil), "live.rtc.v1.StreamResponse")
	proto.RegisterType((*SetRtcConfigRequest)(nil), "live.rtc.v1.SetRtcConfigRequest")
	proto.RegisterType((*SetRtcConfigResponse)(nil), "live.rtc.v1.SetRtcConfigResponse")
	proto.RegisterType((*VerifyTokenRequest)(nil), "live.rtc.v1.VerifyTokenRequest")
	proto.RegisterType((*VerifyTokenResponse)(nil), "live.rtc.v1.VerifyTokenResponse")
	proto.RegisterEnum("live.rtc.v1.MediaSource_MediaType", MediaSource_MediaType_name, MediaSource_MediaType_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// RtcClient is the client API for Rtc service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RtcClient interface {
	// `method:"POST"`
	JoinChannel(ctx context.Context, in *JoinChannelRequest, opts ...grpc.CallOption) (*JoinChannelResponse, error)
	// `method:"POST"`
	LeaveChannel(ctx context.Context, in *LeaveChannelRequest, opts ...grpc.CallOption) (*LeaveChannelResponse, error)
	// `method:"POST"`
	PublishStream(ctx context.Context, in *PublishStreamRequest, opts ...grpc.CallOption) (*PublishStreamResponse, error)
	// `method:"POST"`
	TerminateStream(ctx context.Context, in *TerminateStreamRequest, opts ...grpc.CallOption) (*TerminateStreamResponse, error)
	// `method:"GET"`
	Channel(ctx context.Context, in *ChannelRequest, opts ...grpc.CallOption) (*ChannelResponse, error)
	// `method:"GET"`
	Stream(ctx context.Context, in *StreamRequest, opts ...grpc.CallOption) (*StreamResponse, error)
	// `method:"POST"`
	SetRtcConfig(ctx context.Context, in *SetRtcConfigRequest, opts ...grpc.CallOption) (*SetRtcConfigResponse, error)
	// `method:"GET"`
	VerifyToken(ctx context.Context, in *VerifyTokenRequest, opts ...grpc.CallOption) (*VerifyTokenResponse, error)
}

type rtcClient struct {
	cc *grpc.ClientConn
}

func NewRtcClient(cc *grpc.ClientConn) RtcClient {
	return &rtcClient{cc}
}

func (c *rtcClient) JoinChannel(ctx context.Context, in *JoinChannelRequest, opts ...grpc.CallOption) (*JoinChannelResponse, error) {
	out := new(JoinChannelResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/JoinChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rtcClient) LeaveChannel(ctx context.Context, in *LeaveChannelRequest, opts ...grpc.CallOption) (*LeaveChannelResponse, error) {
	out := new(LeaveChannelResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/LeaveChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rtcClient) PublishStream(ctx context.Context, in *PublishStreamRequest, opts ...grpc.CallOption) (*PublishStreamResponse, error) {
	out := new(PublishStreamResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/PublishStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rtcClient) TerminateStream(ctx context.Context, in *TerminateStreamRequest, opts ...grpc.CallOption) (*TerminateStreamResponse, error) {
	out := new(TerminateStreamResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/TerminateStream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rtcClient) Channel(ctx context.Context, in *ChannelRequest, opts ...grpc.CallOption) (*ChannelResponse, error) {
	out := new(ChannelResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/Channel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rtcClient) Stream(ctx context.Context, in *StreamRequest, opts ...grpc.CallOption) (*StreamResponse, error) {
	out := new(StreamResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/Stream", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rtcClient) SetRtcConfig(ctx context.Context, in *SetRtcConfigRequest, opts ...grpc.CallOption) (*SetRtcConfigResponse, error) {
	out := new(SetRtcConfigResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/SetRtcConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rtcClient) VerifyToken(ctx context.Context, in *VerifyTokenRequest, opts ...grpc.CallOption) (*VerifyTokenResponse, error) {
	out := new(VerifyTokenResponse)
	err := c.cc.Invoke(ctx, "/live.rtc.v1.Rtc/VerifyToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RtcServer is the server API for Rtc service.
type RtcServer interface {
	// `method:"POST"`
	JoinChannel(context.Context, *JoinChannelRequest) (*JoinChannelResponse, error)
	// `method:"POST"`
	LeaveChannel(context.Context, *LeaveChannelRequest) (*LeaveChannelResponse, error)
	// `method:"POST"`
	PublishStream(context.Context, *PublishStreamRequest) (*PublishStreamResponse, error)
	// `method:"POST"`
	TerminateStream(context.Context, *TerminateStreamRequest) (*TerminateStreamResponse, error)
	// `method:"GET"`
	Channel(context.Context, *ChannelRequest) (*ChannelResponse, error)
	// `method:"GET"`
	Stream(context.Context, *StreamRequest) (*StreamResponse, error)
	// `method:"POST"`
	SetRtcConfig(context.Context, *SetRtcConfigRequest) (*SetRtcConfigResponse, error)
	// `method:"GET"`
	VerifyToken(context.Context, *VerifyTokenRequest) (*VerifyTokenResponse, error)
}

func RegisterRtcServer(s *grpc.Server, srv RtcServer) {
	s.RegisterService(&_Rtc_serviceDesc, srv)
}

func _Rtc_JoinChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JoinChannelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).JoinChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/JoinChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).JoinChannel(ctx, req.(*JoinChannelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Rtc_LeaveChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LeaveChannelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).LeaveChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/LeaveChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).LeaveChannel(ctx, req.(*LeaveChannelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Rtc_PublishStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublishStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).PublishStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/PublishStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).PublishStream(ctx, req.(*PublishStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Rtc_TerminateStream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TerminateStreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).TerminateStream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/TerminateStream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).TerminateStream(ctx, req.(*TerminateStreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Rtc_Channel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).Channel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/Channel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).Channel(ctx, req.(*ChannelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Rtc_Stream_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StreamRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).Stream(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/Stream",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).Stream(ctx, req.(*StreamRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Rtc_SetRtcConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetRtcConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).SetRtcConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/SetRtcConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).SetRtcConfig(ctx, req.(*SetRtcConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Rtc_VerifyToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VerifyTokenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RtcServer).VerifyToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/live.rtc.v1.Rtc/VerifyToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RtcServer).VerifyToken(ctx, req.(*VerifyTokenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Rtc_serviceDesc = grpc.ServiceDesc{
	ServiceName: "live.rtc.v1.Rtc",
	HandlerType: (*RtcServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "JoinChannel",
			Handler:    _Rtc_JoinChannel_Handler,
		},
		{
			MethodName: "LeaveChannel",
			Handler:    _Rtc_LeaveChannel_Handler,
		},
		{
			MethodName: "PublishStream",
			Handler:    _Rtc_PublishStream_Handler,
		},
		{
			MethodName: "TerminateStream",
			Handler:    _Rtc_TerminateStream_Handler,
		},
		{
			MethodName: "Channel",
			Handler:    _Rtc_Channel_Handler,
		},
		{
			MethodName: "Stream",
			Handler:    _Rtc_Stream_Handler,
		},
		{
			MethodName: "SetRtcConfig",
			Handler:    _Rtc_SetRtcConfig_Handler,
		},
		{
			MethodName: "VerifyToken",
			Handler:    _Rtc_VerifyToken_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "app/service/live/rtc/api/v1/api.proto",
}

func (m *MediaSource) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MediaSource) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Type))
	}
	if len(m.Codec) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Codec)))
		i += copy(dAtA[i:], m.Codec)
	}
	if len(m.MediaSpecific) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.MediaSpecific)))
		i += copy(dAtA[i:], m.MediaSpecific)
	}
	if m.Ssrc != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Ssrc))
	}
	if m.UserId != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UserId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EncoderConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EncoderConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Width != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Width))
	}
	if m.Height != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Height))
	}
	if m.Bitrate != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Bitrate))
	}
	if m.FrameRate != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.FrameRate))
	}
	if len(m.VideoCodec) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.VideoCodec)))
		i += copy(dAtA[i:], m.VideoCodec)
	}
	if len(m.VideoProfile) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.VideoProfile)))
		i += copy(dAtA[i:], m.VideoProfile)
	}
	if m.Channel != 0 {
		dAtA[i] = 0x98
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Channel))
	}
	if m.SampleRate != 0 {
		dAtA[i] = 0xa0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.SampleRate))
	}
	if len(m.AudioCodec) > 0 {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.AudioCodec)))
		i += copy(dAtA[i:], m.AudioCodec)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *JoinChannelRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JoinChannelRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UserId))
	}
	if m.ProtoVersion != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ProtoVersion))
	}
	if len(m.Source) > 0 {
		for _, msg := range m.Source {
			dAtA[i] = 0x22
			i++
			i = encodeVarintApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *JoinChannelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JoinChannelResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.CallId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CallId))
	}
	if len(m.Token) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Token)))
		i += copy(dAtA[i:], m.Token)
	}
	if len(m.Source) > 0 {
		for _, msg := range m.Source {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *LeaveChannelRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LeaveChannelRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UserId))
	}
	if m.CallId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CallId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *LeaveChannelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LeaveChannelResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *PublishStreamRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PublishStreamRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UserId))
	}
	if m.CallId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CallId))
	}
	if m.EncoderConfig != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.EncoderConfig.Size()))
		n1, err := m.EncoderConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.MixConfig) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.MixConfig)))
		i += copy(dAtA[i:], m.MixConfig)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *PublishStreamResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PublishStreamResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TerminateStreamRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TerminateStreamRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UserId))
	}
	if m.CallId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CallId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TerminateStreamResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TerminateStreamResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ChannelRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChannelRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ChannelResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ChannelResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.MediaSource) > 0 {
		for _, msg := range m.MediaSource {
			dAtA[i] = 0xa
			i++
			i = encodeVarintApi(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Server) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Server)))
		i += copy(dAtA[i:], m.Server)
	}
	if m.TcpPort != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.TcpPort))
	}
	if m.UdpPort != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UdpPort))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *StreamRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StreamRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UserId))
	}
	if m.CallId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CallId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *StreamResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StreamResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.EncoderConfig != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.EncoderConfig.Size()))
		n2, err := m.EncoderConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if len(m.MixConfig) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.MixConfig)))
		i += copy(dAtA[i:], m.MixConfig)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *SetRtcConfigRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetRtcConfigRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.UserId))
	}
	if m.CallId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CallId))
	}
	if len(m.Config) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Config)))
		i += copy(dAtA[i:], m.Config)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *SetRtcConfigResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SetRtcConfigResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *VerifyTokenRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VerifyTokenRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ChannelId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.ChannelId))
	}
	if m.CallId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.CallId))
	}
	if len(m.Token) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(len(m.Token)))
		i += copy(dAtA[i:], m.Token)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *VerifyTokenResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *VerifyTokenResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Pass {
		dAtA[i] = 0x8
		i++
		if m.Pass {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *MediaSource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovApi(uint64(m.Type))
	}
	l = len(m.Codec)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.MediaSpecific)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Ssrc != 0 {
		n += 1 + sovApi(uint64(m.Ssrc))
	}
	if m.UserId != 0 {
		n += 1 + sovApi(uint64(m.UserId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EncoderConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Width != 0 {
		n += 1 + sovApi(uint64(m.Width))
	}
	if m.Height != 0 {
		n += 1 + sovApi(uint64(m.Height))
	}
	if m.Bitrate != 0 {
		n += 1 + sovApi(uint64(m.Bitrate))
	}
	if m.FrameRate != 0 {
		n += 1 + sovApi(uint64(m.FrameRate))
	}
	l = len(m.VideoCodec)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.VideoProfile)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Channel != 0 {
		n += 2 + sovApi(uint64(m.Channel))
	}
	if m.SampleRate != 0 {
		n += 2 + sovApi(uint64(m.SampleRate))
	}
	l = len(m.AudioCodec)
	if l > 0 {
		n += 2 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *JoinChannelRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		n += 1 + sovApi(uint64(m.UserId))
	}
	if m.ProtoVersion != 0 {
		n += 1 + sovApi(uint64(m.ProtoVersion))
	}
	if len(m.Source) > 0 {
		for _, e := range m.Source {
			l = e.Size()
			n += 1 + l + sovApi(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *JoinChannelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CallId != 0 {
		n += 1 + sovApi(uint64(m.CallId))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if len(m.Source) > 0 {
		for _, e := range m.Source {
			l = e.Size()
			n += 1 + l + sovApi(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LeaveChannelRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		n += 1 + sovApi(uint64(m.UserId))
	}
	if m.CallId != 0 {
		n += 1 + sovApi(uint64(m.CallId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LeaveChannelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PublishStreamRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		n += 1 + sovApi(uint64(m.UserId))
	}
	if m.CallId != 0 {
		n += 1 + sovApi(uint64(m.CallId))
	}
	if m.EncoderConfig != nil {
		l = m.EncoderConfig.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.MixConfig)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PublishStreamResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TerminateStreamRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		n += 1 + sovApi(uint64(m.UserId))
	}
	if m.CallId != 0 {
		n += 1 + sovApi(uint64(m.CallId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TerminateStreamResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChannelRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChannelResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.MediaSource) > 0 {
		for _, e := range m.MediaSource {
			l = e.Size()
			n += 1 + l + sovApi(uint64(l))
		}
	}
	l = len(m.Server)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.TcpPort != 0 {
		n += 1 + sovApi(uint64(m.TcpPort))
	}
	if m.UdpPort != 0 {
		n += 1 + sovApi(uint64(m.UdpPort))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StreamRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		n += 1 + sovApi(uint64(m.UserId))
	}
	if m.CallId != 0 {
		n += 1 + sovApi(uint64(m.CallId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StreamResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EncoderConfig != nil {
		l = m.EncoderConfig.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	l = len(m.MixConfig)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SetRtcConfigRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.UserId != 0 {
		n += 1 + sovApi(uint64(m.UserId))
	}
	if m.CallId != 0 {
		n += 1 + sovApi(uint64(m.CallId))
	}
	l = len(m.Config)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SetRtcConfigResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VerifyTokenRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ChannelId != 0 {
		n += 1 + sovApi(uint64(m.ChannelId))
	}
	if m.CallId != 0 {
		n += 1 + sovApi(uint64(m.CallId))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovApi(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *VerifyTokenResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Pass {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovApi(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozApi(x uint64) (n int) {
	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MediaSource) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MediaSource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MediaSource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (MediaSource_MediaType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Codec", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Codec = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MediaSpecific", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MediaSpecific = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ssrc", wireType)
			}
			m.Ssrc = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ssrc |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EncoderConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EncoderConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EncoderConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Width", wireType)
			}
			m.Width = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Width |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bitrate", wireType)
			}
			m.Bitrate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bitrate |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrameRate", wireType)
			}
			m.FrameRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FrameRate |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VideoCodec", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VideoCodec = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VideoProfile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VideoProfile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Channel", wireType)
			}
			m.Channel = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Channel |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SampleRate", wireType)
			}
			m.SampleRate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SampleRate |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AudioCodec", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AudioCodec = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JoinChannelRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JoinChannelRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JoinChannelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProtoVersion", wireType)
			}
			m.ProtoVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProtoVersion |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, &MediaSource{})
			if err := m.Source[len(m.Source)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JoinChannelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JoinChannelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JoinChannelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallId", wireType)
			}
			m.CallId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallId |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Source = append(m.Source, &MediaSource{})
			if err := m.Source[len(m.Source)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LeaveChannelRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LeaveChannelRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LeaveChannelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallId", wireType)
			}
			m.CallId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallId |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LeaveChannelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LeaveChannelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LeaveChannelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PublishStreamRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PublishStreamRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PublishStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallId", wireType)
			}
			m.CallId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallId |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncoderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EncoderConfig == nil {
				m.EncoderConfig = &EncoderConfig{}
			}
			if err := m.EncoderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixConfig", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixConfig = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PublishStreamResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PublishStreamResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PublishStreamResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TerminateStreamRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TerminateStreamRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TerminateStreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallId", wireType)
			}
			m.CallId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallId |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TerminateStreamResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TerminateStreamResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TerminateStreamResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChannelRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ChannelRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChannelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChannelResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ChannelResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChannelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MediaSource", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MediaSource = append(m.MediaSource, &MediaSource{})
			if err := m.MediaSource[len(m.MediaSource)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Server", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Server = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TcpPort", wireType)
			}
			m.TcpPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TcpPort |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UdpPort", wireType)
			}
			m.UdpPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UdpPort |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StreamRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StreamRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallId", wireType)
			}
			m.CallId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallId |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StreamResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StreamResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncoderConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EncoderConfig == nil {
				m.EncoderConfig = &EncoderConfig{}
			}
			if err := m.EncoderConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixConfig", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixConfig = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetRtcConfigRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetRtcConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetRtcConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType)
			}
			m.UserId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UserId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallId", wireType)
			}
			m.CallId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallId |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Config = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SetRtcConfigResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetRtcConfigResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetRtcConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyTokenRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VerifyTokenRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyTokenRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallId", wireType)
			}
			m.CallId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallId |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *VerifyTokenResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: VerifyTokenResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VerifyTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pass", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Pass = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApi(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowApi
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthApi
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowApi
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipApi(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApi   = fmt.Errorf("proto: integer overflow")
)

func init() {
	proto.RegisterFile("app/service/live/rtc/api/v1/api.proto", fileDescriptor_api_cc75e2c1742b635b)
}

var fileDescriptor_api_cc75e2c1742b635b = []byte{
	// 1116 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x6e, 0x23, 0xc5,
	0x13, 0xff, 0xb7, 0xed, 0xd8, 0x71, 0x39, 0x76, 0xfc, 0x6f, 0x67, 0x77, 0x8d, 0x37, 0xca, 0x98,
	0x61, 0x57, 0xe4, 0x12, 0x9b, 0x64, 0x25, 0x24, 0x24, 0x24, 0xc8, 0x97, 0x20, 0xab, 0x44, 0x89,
	0xda, 0xd9, 0x1c, 0x10, 0x92, 0x35, 0x99, 0x69, 0xc7, 0x2d, 0x6c, 0xcf, 0x30, 0x33, 0x36, 0x9b,
	0x57, 0xd8, 0x13, 0x02, 0x09, 0x24, 0xee, 0xbc, 0x01, 0x07, 0x1e, 0x81, 0x23, 0x27, 0x8e, 0x06,
	0xe5, 0xe8, 0xa7, 0x40, 0x5d, 0xdd, 0x8e, 0x67, 0x9c, 0x49, 0x16, 0x2d, 0x08, 0x72, 0x99, 0xae,
	0xaa, 0xae, 0x6a, 0xff, 0xea, 0xdb, 0xf0, 0xd4, 0xf2, 0xbc, 0x66, 0xc0, 0xfd, 0x91, 0xb0, 0x79,
	0xb3, 0x27, 0x46, 0xbc, 0xe9, 0x87, 0x76, 0xd3, 0xf2, 0x44, 0x73, 0xb4, 0x29, 0x8f, 0x86, 0xe7,
	0xbb, 0xa1, 0x4b, 0x0b, 0xf2, 0xaa, 0xe1, 0x87, 0x76, 0x63, 0xb4, 0x59, 0xdb, 0xb8, 0x10, 0x61,
	0x77, 0x78, 0xde, 0xb0, 0xdd, 0x7e, 0xf3, 0xc2, 0xbd, 0x70, 0x9b, 0xa8, 0x73, 0x3e, 0xec, 0x20,
	0x87, 0x0c, 0x52, 0xca, 0xd6, 0xfc, 0x39, 0x05, 0x85, 0x23, 0xee, 0x08, 0xab, 0xe5, 0x0e, 0x7d,
	0x9b, 0xd3, 0x8f, 0x21, 0x13, 0x5e, 0x7a, 0xbc, 0x4a, 0xea, 0x64, 0xbd, 0xb4, 0x65, 0x36, 0x22,
	0x4f, 0x37, 0x22, 0x7a, 0x8a, 0x3e, 0xbd, 0xf4, 0xf8, 0xce, 0xe2, 0x64, 0x6c, 0xa0, 0x0d, 0xc3,
	0x2f, 0x35, 0x60, 0xc1, 0x76, 0x1d, 0x6e, 0x57, 0x53, 0x75, 0xb2, 0x9e, 0xdf, 0xc9, 0x4f, 0xc6,
	0x86, 0x12, 0x30, 0x75, 0xd0, 0x0f, 0xa0, 0xd4, 0x97, 0xd6, 0xed, 0xc0, 0xe3, 0xb6, 0xe8, 0x08,
	0xbb, 0x9a, 0x46, 0x4d, 0x3a, 0x19, 0x1b, 0x73, 0x37, 0xac, 0x88, 0x7c, 0x4b, 0xb3, 0x74, 0x15,
	0x32, 0x41, 0xe0, 0xdb, 0xd5, 0x4c, 0x9d, 0xac, 0x17, 0xd5, 0x2f, 0x4b, 0x9e, 0xe1, 0x97, 0x3e,
	0x81, 0xdc, 0x30, 0xe0, 0x7e, 0x5b, 0x38, 0xd5, 0x85, 0x3a, 0x59, 0xcf, 0xec, 0x14, 0x26, 0x63,
	0x63, 0x2a, 0x62, 0x59, 0x49, 0x1c, 0x38, 0xe6, 0x27, 0x90, 0xbf, 0x06, 0x4f, 0xf3, 0xb0, 0x70,
	0x7c, 0xfa, 0xe9, 0x3e, 0x2b, 0xff, 0x4f, 0x92, 0x67, 0x07, 0x7b, 0xfb, 0xc7, 0x65, 0x22, 0xc9,
	0xed, 0x17, 0x7b, 0x07, 0xc7, 0xe5, 0x14, 0x5d, 0x84, 0xcc, 0xde, 0xf6, 0xe9, 0x76, 0x39, 0x4d,
	0x97, 0xa1, 0xd0, 0x3a, 0xda, 0x3e, 0x3c, 0x6c, 0x2b, 0xad, 0x8c, 0xf9, 0x63, 0x1a, 0x8a, 0xfb,
	0x03, 0xe9, 0x93, 0xbf, 0xeb, 0x0e, 0x3a, 0xe2, 0x42, 0xba, 0xfe, 0x95, 0x70, 0xc2, 0x2e, 0x46,
	0xaf, 0xa8, 0x5c, 0x47, 0x01, 0x53, 0x07, 0x35, 0x21, 0xdb, 0xe5, 0xe2, 0xa2, 0x1b, 0x62, 0x70,
	0x8a, 0x3b, 0x30, 0x19, 0x1b, 0x5a, 0xc2, 0xf4, 0x49, 0x9f, 0x42, 0xee, 0x5c, 0x84, 0xbe, 0x15,
	0x72, 0x8c, 0x4b, 0x51, 0x79, 0xa1, 0x45, 0x6c, 0x4a, 0xd0, 0x0d, 0x80, 0x8e, 0x6f, 0xf5, 0x79,
	0x1b, 0x35, 0x55, 0x40, 0x4a, 0x93, 0xb1, 0x11, 0x91, 0xb2, 0x3c, 0xd2, 0x4c, 0xaa, 0xbf, 0x07,
	0x85, 0x91, 0x70, 0xb8, 0xdb, 0x56, 0xb9, 0x59, 0xc0, 0x88, 0x2f, 0x4f, 0xc6, 0x46, 0x54, 0xcc,
	0x00, 0x99, 0x5d, 0x4c, 0xd3, 0xfb, 0x50, 0x54, 0x57, 0x9e, 0xef, 0x76, 0x44, 0x8f, 0x57, 0xb3,
	0x68, 0xf3, 0xff, 0xc9, 0xd8, 0x88, 0x5f, 0xb0, 0x25, 0x64, 0x4f, 0x14, 0x27, 0xf1, 0xdb, 0x5d,
	0x6b, 0x30, 0xe0, 0xbd, 0x6a, 0x65, 0x86, 0x5f, 0x8b, 0xd8, 0x94, 0x90, 0x80, 0x02, 0xab, 0xef,
	0xf5, 0xb4, 0x03, 0x2b, 0xa8, 0x8a, 0x80, 0x22, 0x62, 0x06, 0x8a, 0x99, 0xba, 0x60, 0x0d, 0x1d,
	0x31, 0x75, 0xe1, 0xc1, 0xcc, 0x85, 0x88, 0x98, 0x01, 0x32, 0xe8, 0xc2, 0xf3, 0xcc, 0x62, 0xae,
	0x5c, 0x31, 0x7f, 0x27, 0x40, 0x9f, 0xbb, 0x62, 0xb0, 0xab, 0x21, 0xf0, 0x2f, 0x87, 0x3c, 0x08,
	0x65, 0x00, 0x35, 0x16, 0x59, 0x30, 0x04, 0x0b, 0x06, 0x03, 0x38, 0x93, 0xb2, 0xbc, 0xa6, 0x0f,
	0x9c, 0x68, 0x71, 0xa5, 0x6e, 0x2d, 0x2e, 0x19, 0x34, 0xec, 0xab, 0xf6, 0x88, 0xfb, 0x81, 0x70,
	0x07, 0x3a, 0x85, 0x18, 0xb4, 0xd8, 0x05, 0x5b, 0x42, 0xf6, 0x4c, 0x71, 0xf4, 0x43, 0xc8, 0x06,
	0xd8, 0x58, 0xd5, 0x4c, 0x3d, 0xbd, 0x5e, 0xd8, 0xaa, 0xde, 0xd6, 0x78, 0xaa, 0x64, 0x94, 0x2e,
	0xd3, 0xa7, 0xf9, 0x03, 0x81, 0x4a, 0xcc, 0xc3, 0xc0, 0x73, 0x07, 0x01, 0x97, 0x98, 0x6d, 0xab,
	0x77, 0xed, 0xdf, 0x34, 0x15, 0x4a, 0xc4, 0xb2, 0x92, 0x38, 0x70, 0x64, 0xd5, 0x86, 0xee, 0x17,
	0x7c, 0x10, 0x6d, 0x58, 0x14, 0x30, 0x75, 0x44, 0xc0, 0xa5, 0xdf, 0x00, 0xdc, 0xd7, 0x04, 0x2a,
	0x87, 0xdc, 0x1a, 0xf1, 0x7f, 0x23, 0xfe, 0x11, 0x8f, 0xd3, 0xb7, 0x7a, 0x6c, 0x3e, 0x84, 0x95,
	0x38, 0x22, 0x15, 0x2f, 0xf3, 0xfb, 0x14, 0xac, 0x9c, 0x0c, 0xcf, 0x7b, 0x22, 0xe8, 0xb6, 0x42,
	0x9f, 0x5b, 0xfd, 0xff, 0x1e, 0x2b, 0x7d, 0x01, 0x25, 0xae, 0x86, 0x4c, 0xdb, 0xc6, 0x29, 0x83,
	0xbd, 0x5e, 0xd8, 0xaa, 0xc5, 0x92, 0x10, 0x9b, 0x43, 0x6a, 0x92, 0xc6, 0xad, 0x58, 0x91, 0xc7,
	0x46, 0xd5, 0x06, 0x40, 0x5f, 0xbc, 0x9c, 0x3e, 0xa9, 0xc6, 0x01, 0x7a, 0x34, 0x93, 0xb2, 0x7c,
	0x5f, 0xbc, 0x54, 0xea, 0xe6, 0x23, 0x78, 0x30, 0x17, 0x18, 0x1d, 0xb2, 0x6f, 0x09, 0x3c, 0x3c,
	0xe5, 0x7e, 0x5f, 0x0c, 0xac, 0x90, 0xdf, 0x97, 0xa0, 0x99, 0x6f, 0xc1, 0xa3, 0x1b, 0xa0, 0x34,
	0xe0, 0x8f, 0xa0, 0xf4, 0xb7, 0x0a, 0xd1, 0xfc, 0x8d, 0xc0, 0xf2, 0x7c, 0xa3, 0x1d, 0xc1, 0x92,
	0x5e, 0x5c, 0xaa, 0x4f, 0xc8, 0x6b, 0xfa, 0xa4, 0x3c, 0x19, 0x1b, 0x31, 0x0b, 0x56, 0xe8, 0x47,
	0x96, 0xb0, 0x09, 0x59, 0xb9, 0xf5, 0xb9, 0xaf, 0x5b, 0x52, 0xb5, 0x15, 0x4a, 0x98, 0x3e, 0xe9,
	0xbb, 0xb0, 0x18, 0xda, 0x5e, 0xdb, 0x73, 0xfd, 0x50, 0x47, 0x62, 0x69, 0x32, 0x36, 0xae, 0x65,
	0x2c, 0x17, 0xda, 0xde, 0x89, 0xeb, 0x87, 0x52, 0x71, 0xe8, 0x68, 0xc5, 0xcc, 0x4c, 0x71, 0x2a,
	0x63, 0xb9, 0xa1, 0x83, 0x8a, 0xe6, 0x2b, 0x02, 0xc5, 0x7b, 0x93, 0xc1, 0xef, 0x08, 0x94, 0xe2,
	0x99, 0x4b, 0xe8, 0x04, 0xf2, 0xcf, 0x77, 0x42, 0xea, 0x75, 0x9d, 0xf0, 0x13, 0x81, 0x4a, 0x8b,
	0x87, 0x2c, 0xb4, 0x95, 0xe0, 0x1e, 0x8c, 0x08, 0x13, 0xb2, 0x91, 0xd1, 0xa0, 0xcb, 0x45, 0x23,
	0xd7, 0xa7, 0x1c, 0x79, 0x71, 0xd4, 0xba, 0x1d, 0x5e, 0x11, 0xa0, 0x67, 0xdc, 0x17, 0x9d, 0xcb,
	0x53, 0x1c, 0xf9, 0x6f, 0xec, 0xcd, 0x14, 0x67, 0xea, 0x2f, 0x2c, 0x9a, 0x74, 0xf2, 0xa2, 0x31,
	0x9f, 0x41, 0x25, 0x86, 0x45, 0x27, 0x7e, 0x15, 0x32, 0x9e, 0x15, 0x04, 0x08, 0x63, 0x51, 0xfd,
	0xeb, 0x93, 0x3c, 0xc3, 0xef, 0xd6, 0x37, 0x0b, 0x90, 0x66, 0xa1, 0x4d, 0x4f, 0xa0, 0x10, 0xd9,
	0x81, 0xd4, 0x88, 0x55, 0xc5, 0xcd, 0xfd, 0x5f, 0xab, 0xdf, 0xae, 0xa0, 0x7f, 0xb7, 0x05, 0x4b,
	0xd1, 0x35, 0x41, 0xe3, 0x16, 0x09, 0x3b, 0xad, 0xf6, 0xf6, 0x1d, 0x1a, 0xfa, 0xd1, 0x33, 0x28,
	0xc6, 0x26, 0x29, 0x8d, 0xdb, 0x24, 0xad, 0x9f, 0x9a, 0x79, 0x97, 0x8a, 0x7e, 0xf7, 0x73, 0x58,
	0x9e, 0x1b, 0x79, 0xf4, 0x9d, 0x98, 0x59, 0xf2, 0x94, 0xae, 0x3d, 0xb9, 0x5b, 0x49, 0xbf, 0xbe,
	0x07, 0xb9, 0x69, 0x14, 0x1e, 0xc7, 0x0c, 0xe6, 0x02, 0xb0, 0x9a, 0x7c, 0xa9, 0x5f, 0xd9, 0x86,
	0xac, 0x86, 0x16, 0xef, 0xd9, 0x38, 0xa2, 0xc7, 0x89, 0x77, 0xb3, 0x9c, 0x44, 0xeb, 0x78, 0x2e,
	0x27, 0x09, 0x8d, 0x39, 0x97, 0x93, 0xa4, 0x26, 0x90, 0xa5, 0x13, 0xa9, 0xbb, 0xb9, 0xd2, 0xb9,
	0xd9, 0x1d, 0x73, 0xa5, 0x93, 0x50, 0xb2, 0x3b, 0xe5, 0x5f, 0xae, 0xd6, 0xc8, 0xaf, 0x57, 0x6b,
	0xe4, 0x8f, 0xab, 0x35, 0xf2, 0x59, 0x6a, 0xb4, 0x79, 0x9e, 0xc5, 0xff, 0x7b, 0xcf, 0xfe, 0x0c,
	0x00, 0x00, 0xff, 0xff, 0x48, 0x5f, 0x3e, 0x7f, 0xd4, 0x0d, 0x00, 0x00,
}