chromium/out/Default/gen/third_party/openscreen/src/cast/streaming/remoting.pb.cc

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: remoting.proto

#include "remoting.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace openscreen {
namespace cast {
PROTOBUF_CONSTEXPR DecoderBuffer::DecoderBuffer(
    ::_pbi::ConstantInitialized):{}
struct DecoderBufferDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DecoderBufferDefaultTypeInternal _DecoderBuffer_default_instance_;
PROTOBUF_CONSTEXPR Size::Size(
    ::_pbi::ConstantInitialized):{}
struct SizeDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SizeDefaultTypeInternal _Size_default_instance_;
PROTOBUF_CONSTEXPR AudioDecoderConfig::AudioDecoderConfig(
    ::_pbi::ConstantInitialized):{}
struct AudioDecoderConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioDecoderConfigDefaultTypeInternal _AudioDecoderConfig_default_instance_;
PROTOBUF_CONSTEXPR Rect::Rect(
    ::_pbi::ConstantInitialized):{}
struct RectDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RectDefaultTypeInternal _Rect_default_instance_;
PROTOBUF_CONSTEXPR VideoDecoderConfig::VideoDecoderConfig(
    ::_pbi::ConstantInitialized):{}
struct VideoDecoderConfigDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VideoDecoderConfigDefaultTypeInternal _VideoDecoderConfig_default_instance_;
PROTOBUF_CONSTEXPR AudioDecoderInfo::AudioDecoderInfo(
    ::_pbi::ConstantInitialized):{}
struct AudioDecoderInfoDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AudioDecoderInfoDefaultTypeInternal _AudioDecoderInfo_default_instance_;
PROTOBUF_CONSTEXPR VideoDecoderInfo::VideoDecoderInfo(
    ::_pbi::ConstantInitialized):{}
struct VideoDecoderInfoDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VideoDecoderInfoDefaultTypeInternal _VideoDecoderInfo_default_instance_;
PROTOBUF_CONSTEXPR PipelineStatistics::PipelineStatistics(
    ::_pbi::ConstantInitialized):{}
struct PipelineStatisticsDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PipelineStatisticsDefaultTypeInternal _PipelineStatistics_default_instance_;
PROTOBUF_CONSTEXPR AcquireDemuxer::AcquireDemuxer(
    ::_pbi::ConstantInitialized):{}
struct AcquireDemuxerDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AcquireDemuxerDefaultTypeInternal _AcquireDemuxer_default_instance_;
PROTOBUF_CONSTEXPR RendererInitialize::RendererInitialize(
    ::_pbi::ConstantInitialized):{}
struct RendererInitializeDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RendererInitializeDefaultTypeInternal _RendererInitialize_default_instance_;
PROTOBUF_CONSTEXPR RendererFlushUntil::RendererFlushUntil(
    ::_pbi::ConstantInitialized):{}
struct RendererFlushUntilDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RendererFlushUntilDefaultTypeInternal _RendererFlushUntil_default_instance_;
PROTOBUF_CONSTEXPR RendererClientOnTimeUpdate::RendererClientOnTimeUpdate(
    ::_pbi::ConstantInitialized):{}
struct RendererClientOnTimeUpdateDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RendererClientOnTimeUpdateDefaultTypeInternal _RendererClientOnTimeUpdate_default_instance_;
PROTOBUF_CONSTEXPR RendererClientOnBufferingStateChange::RendererClientOnBufferingStateChange(
    ::_pbi::ConstantInitialized):{}
struct RendererClientOnBufferingStateChangeDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RendererClientOnBufferingStateChangeDefaultTypeInternal _RendererClientOnBufferingStateChange_default_instance_;
PROTOBUF_CONSTEXPR RendererClientOnAudioConfigChange::RendererClientOnAudioConfigChange(
    ::_pbi::ConstantInitialized):{}
struct RendererClientOnAudioConfigChangeDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RendererClientOnAudioConfigChangeDefaultTypeInternal _RendererClientOnAudioConfigChange_default_instance_;
PROTOBUF_CONSTEXPR RendererClientOnVideoConfigChange::RendererClientOnVideoConfigChange(
    ::_pbi::ConstantInitialized):{}
struct RendererClientOnVideoConfigChangeDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RendererClientOnVideoConfigChangeDefaultTypeInternal _RendererClientOnVideoConfigChange_default_instance_;
PROTOBUF_CONSTEXPR RemotingError::RemotingError(
    ::_pbi::ConstantInitialized):{}
struct RemotingErrorDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RemotingErrorDefaultTypeInternal _RemotingError_default_instance_;
PROTOBUF_CONSTEXPR DemuxerStreamReadUntil::DemuxerStreamReadUntil(
    ::_pbi::ConstantInitialized):{}
struct DemuxerStreamReadUntilDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DemuxerStreamReadUntilDefaultTypeInternal _DemuxerStreamReadUntil_default_instance_;
PROTOBUF_CONSTEXPR DemuxerStreamInitializeCallback::DemuxerStreamInitializeCallback(
    ::_pbi::ConstantInitialized):{}
struct DemuxerStreamInitializeCallbackDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DemuxerStreamInitializeCallbackDefaultTypeInternal _DemuxerStreamInitializeCallback_default_instance_;
PROTOBUF_CONSTEXPR DemuxerStreamReadUntilCallback::DemuxerStreamReadUntilCallback(
    ::_pbi::ConstantInitialized):{}
struct DemuxerStreamReadUntilCallbackDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DemuxerStreamReadUntilCallbackDefaultTypeInternal _DemuxerStreamReadUntilCallback_default_instance_;
PROTOBUF_CONSTEXPR RpcMessage::RpcMessage(
    ::_pbi::ConstantInitialized):{}
struct RpcMessageDefaultTypeInternal {};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RpcMessageDefaultTypeInternal _RpcMessage_default_instance_;
}  // namespace cast
}  // namespace openscreen
namespace openscreen {
namespace cast {
bool AudioDecoderConfig_Codec_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AudioDecoderConfig_Codec_strings[21] =;

static const char AudioDecoderConfig_Codec_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AudioDecoderConfig_Codec_entries[] =;

static const int AudioDecoderConfig_Codec_entries_by_number[] =;

const std::string& AudioDecoderConfig_Codec_Name(
    AudioDecoderConfig_Codec value) {}
bool AudioDecoderConfig_Codec_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AudioDecoderConfig_Codec* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kUnknownAudioCodec;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAAC;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecMP3;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecVorbis;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecFLAC;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAMR_NB;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAMR_WB;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_MULAW;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecGSM_MS;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_S16BE;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_S24BE;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecOpus;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecEAC3;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecPCM_ALAW;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecALAC;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecAC3;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecMpegHAudio;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecDTS;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecDTSXP2;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::kCodecDTSE;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::Codec_MIN;
constexpr AudioDecoderConfig_Codec AudioDecoderConfig::Codec_MAX;
constexpr int AudioDecoderConfig::Codec_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool AudioDecoderConfig_SampleFormat_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AudioDecoderConfig_SampleFormat_strings[15] =;

static const char AudioDecoderConfig_SampleFormat_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AudioDecoderConfig_SampleFormat_entries[] =;

static const int AudioDecoderConfig_SampleFormat_entries_by_number[] =;

const std::string& AudioDecoderConfig_SampleFormat_Name(
    AudioDecoderConfig_SampleFormat value) {}
bool AudioDecoderConfig_SampleFormat_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AudioDecoderConfig_SampleFormat* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kUnknownSampleFormat;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatU8;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatS16;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatS32;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatF32;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatPlanarS16;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatPlanarF32;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatPlanarS32;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatS24;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatAc3;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatEac3;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatMpegHAudio;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatPlanarU8;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatDts;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::kSampleFormatDtsxP2;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::SampleFormat_MIN;
constexpr AudioDecoderConfig_SampleFormat AudioDecoderConfig::SampleFormat_MAX;
constexpr int AudioDecoderConfig::SampleFormat_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool AudioDecoderConfig_ChannelLayout_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AudioDecoderConfig_ChannelLayout_strings[33] =;

static const char AudioDecoderConfig_ChannelLayout_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AudioDecoderConfig_ChannelLayout_entries[] =;

static const int AudioDecoderConfig_ChannelLayout_entries_by_number[] =;

const std::string& AudioDecoderConfig_ChannelLayout_Name(
    AudioDecoderConfig_ChannelLayout value) {}
bool AudioDecoderConfig_ChannelLayout_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AudioDecoderConfig_ChannelLayout* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_NONE;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_UNSUPPORTED;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_MONO;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_STEREO;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_2_1;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_SURROUND;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_4_0;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_2_2;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_QUAD;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_0;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_1;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_0_BACK;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_5_1_BACK;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_0;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_1;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_1_WIDE;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_STEREO_DOWNMIX;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_2POINT1;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_3_1;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_4_1;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_0;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_0_FRONT;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_HEXAGONAL;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_1;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_1_BACK;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_6_1_FRONT;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_0_FRONT;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_7_1_WIDE_BACK;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_OCTAGONAL;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_DISCRETE;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_STEREO_AND_KEYBOARD_MIC;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_4_1_QUAD_SIDE;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::CHANNEL_LAYOUT_BITSTREAM;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::ChannelLayout_MIN;
constexpr AudioDecoderConfig_ChannelLayout AudioDecoderConfig::ChannelLayout_MAX;
constexpr int AudioDecoderConfig::ChannelLayout_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool VideoDecoderConfig_Codec_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VideoDecoderConfig_Codec_strings[11] =;

static const char VideoDecoderConfig_Codec_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VideoDecoderConfig_Codec_entries[] =;

static const int VideoDecoderConfig_Codec_entries_by_number[] =;

const std::string& VideoDecoderConfig_Codec_Name(
    VideoDecoderConfig_Codec value) {}
bool VideoDecoderConfig_Codec_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VideoDecoderConfig_Codec* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kUnknownVideoCodec;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecH264;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecVC1;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecMPEG2;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecMPEG4;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecTheora;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecVP8;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecVP9;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecHEVC;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecDolbyVision;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::kCodecAV1;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::Codec_MIN;
constexpr VideoDecoderConfig_Codec VideoDecoderConfig::Codec_MAX;
constexpr int VideoDecoderConfig::Codec_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool VideoDecoderConfig_Profile_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VideoDecoderConfig_Profile_strings[37] =;

static const char VideoDecoderConfig_Profile_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VideoDecoderConfig_Profile_entries[] =;

static const int VideoDecoderConfig_Profile_entries_by_number[] =;

const std::string& VideoDecoderConfig_Profile_Name(
    VideoDecoderConfig_Profile value) {}
bool VideoDecoderConfig_Profile_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VideoDecoderConfig_Profile* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::VIDEO_CODEC_PROFILE_UNKNOWN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_BASELINE;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_MAIN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_EXTENDED;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH10PROFILE;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH422PROFILE;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_HIGH444PREDICTIVEPROFILE;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_SCALABLEBASELINE;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_SCALABLEHIGH;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_STEREOHIGH;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::H264PROFILE_MULTIVIEWHIGH;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::VP8PROFILE_ANY;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE0;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE1;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE2;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::VP9PROFILE_PROFILE3;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_MAIN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_MAIN10;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_MAIN_STILL_PICTURE;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE0;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE5;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE7;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::THEORAPROFILE_ANY;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::AV1PROFILE_PROFILE_MAIN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::AV1PROFILE_PROFILE_HIGH;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::AV1PROFILE_PROFILE_PRO;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE8;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::DOLBYVISION_PROFILE9;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_REXT;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_HIGH_THROUGHPUT;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_MULTIVIEW_MAIN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_SCALABLE_MAIN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_3D_MAIN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_SCREEN_EXTENDED;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_SCALABLE_REXT;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::HEVCPROFILE_HIGH_THROUGHPUT_SCREEN_EXTENDED;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::Profile_MIN;
constexpr VideoDecoderConfig_Profile VideoDecoderConfig::Profile_MAX;
constexpr int VideoDecoderConfig::Profile_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool VideoDecoderConfig_Format_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VideoDecoderConfig_Format_strings[41] =;

static const char VideoDecoderConfig_Format_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VideoDecoderConfig_Format_entries[] =;

static const int VideoDecoderConfig_Format_entries_by_number[] =;

const std::string& VideoDecoderConfig_Format_Name(
    VideoDecoderConfig_Format value) {}
bool VideoDecoderConfig_Format_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VideoDecoderConfig_Format* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_UNKNOWN;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I420;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YV12;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I422;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I420A;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I444;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_NV12;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_NV21;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUY2;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_ARGB;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_XRGB;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_RGB24;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_RGB32;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_MJPEG;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV420P9;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV420P10;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV422P9;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV422P10;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV444P9;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV444P10;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV420P12;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV422P12;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV444P12;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_Y16;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_ABGR;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_XBGR;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_P010LE;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_XR30;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_XB30;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_BGRA;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_RGBAF16;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I422A;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_I444A;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV420AP10;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV422AP10;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_YUV444AP10;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_NV12A;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_NV16;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_NV24;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_P210LE;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::PIXEL_FORMAT_P410LE;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::Format_MIN;
constexpr VideoDecoderConfig_Format VideoDecoderConfig::Format_MAX;
constexpr int VideoDecoderConfig::Format_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool VideoDecoderConfig_ColorSpace_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> VideoDecoderConfig_ColorSpace_strings[4] =;

static const char VideoDecoderConfig_ColorSpace_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry VideoDecoderConfig_ColorSpace_entries[] =;

static const int VideoDecoderConfig_ColorSpace_entries_by_number[] =;

const std::string& VideoDecoderConfig_ColorSpace_Name(
    VideoDecoderConfig_ColorSpace value) {}
bool VideoDecoderConfig_ColorSpace_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VideoDecoderConfig_ColorSpace* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_UNSPECIFIED;
constexpr VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_JPEG;
constexpr VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_HD_REC709;
constexpr VideoDecoderConfig_ColorSpace VideoDecoderConfig::COLOR_SPACE_SD_REC601;
constexpr VideoDecoderConfig_ColorSpace VideoDecoderConfig::ColorSpace_MIN;
constexpr VideoDecoderConfig_ColorSpace VideoDecoderConfig::ColorSpace_MAX;
constexpr int VideoDecoderConfig::ColorSpace_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool RendererClientOnBufferingStateChange_State_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> RendererClientOnBufferingStateChange_State_strings[2] =;

static const char RendererClientOnBufferingStateChange_State_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RendererClientOnBufferingStateChange_State_entries[] =;

static const int RendererClientOnBufferingStateChange_State_entries_by_number[] =;

const std::string& RendererClientOnBufferingStateChange_State_Name(
    RendererClientOnBufferingStateChange_State value) {}
bool RendererClientOnBufferingStateChange_State_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RendererClientOnBufferingStateChange_State* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::BUFFERING_HAVE_NOTHING;
constexpr RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::BUFFERING_HAVE_ENOUGH;
constexpr RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::State_MIN;
constexpr RendererClientOnBufferingStateChange_State RendererClientOnBufferingStateChange::State_MAX;
constexpr int RendererClientOnBufferingStateChange::State_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool RemotingError_ErrorType_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> RemotingError_ErrorType_strings[19] =;

static const char RemotingError_ErrorType_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RemotingError_ErrorType_entries[] =;

static const int RemotingError_ErrorType_entries_by_number[] =;

const std::string& RemotingError_ErrorType_Name(
    RemotingError_ErrorType value) {}
bool RemotingError_ErrorType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RemotingError_ErrorType* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineNetwork;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineDecode;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineAbort;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineInitializationFailed;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineCouldNotRender;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineRead;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineInvalidState;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineExternalRendererFailed;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineHardwareContextReset;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineDisconnected;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineDemuxerCouldNotOpen;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineDemuxerCouldNotParse;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineDemuxerNoSupportedStreams;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineDemuxerDetectedHls;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineDecoderNotSupported;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineChunkDemuxerAppendFailed;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineChunkDemuxerEosStatusDecode;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineChunkDemuxerEosStatusNetwork;
constexpr RemotingError_ErrorType RemotingError::kMediaPipelineAudioRenderer;
constexpr RemotingError_ErrorType RemotingError::ErrorType_MIN;
constexpr RemotingError_ErrorType RemotingError::ErrorType_MAX;
constexpr int RemotingError::ErrorType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DemuxerStreamReadUntilCallback_Status_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DemuxerStreamReadUntilCallback_Status_strings[4] =;

static const char DemuxerStreamReadUntilCallback_Status_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DemuxerStreamReadUntilCallback_Status_entries[] =;

static const int DemuxerStreamReadUntilCallback_Status_entries_by_number[] =;

const std::string& DemuxerStreamReadUntilCallback_Status_Name(
    DemuxerStreamReadUntilCallback_Status value) {}
bool DemuxerStreamReadUntilCallback_Status_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DemuxerStreamReadUntilCallback_Status* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kOk;
constexpr DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kAborted;
constexpr DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kConfigChanged;
constexpr DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::kError;
constexpr DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::Status_MIN;
constexpr DemuxerStreamReadUntilCallback_Status DemuxerStreamReadUntilCallback::Status_MAX;
constexpr int DemuxerStreamReadUntilCallback::Status_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool RpcMessage_RpcProc_IsValid(int value) {}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> RpcMessage_RpcProc_strings[29] =;

static const char RpcMessage_RpcProc_names[] =;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry RpcMessage_RpcProc_entries[] =;

static const int RpcMessage_RpcProc_entries_by_number[] =;

const std::string& RpcMessage_RpcProc_Name(
    RpcMessage_RpcProc value) {}
bool RpcMessage_RpcProc_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RpcMessage_RpcProc* value) {}
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr RpcMessage_RpcProc RpcMessage::RPC_INTERNAL;
constexpr RpcMessage_RpcProc RpcMessage::RPC_ACQUIRE_RENDERER;
constexpr RpcMessage_RpcProc RpcMessage::RPC_ACQUIRE_DEMUXER;
constexpr RpcMessage_RpcProc RpcMessage::RPC_ACQUIRE_RENDERER_DONE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_ONREMOTINGERROR;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_INITIALIZE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_FLUSHUNTIL;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_STARTPLAYINGFROM;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_SETPLAYBACKRATE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_SETVOLUME;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_INITIALIZE_CALLBACK;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_FLUSHUNTIL_CALLBACK;
constexpr RpcMessage_RpcProc RpcMessage::RPC_R_SETCDM_CALLBACK;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONTIMEUPDATE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONBUFFERINGSTATECHANGE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONENDED;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONERROR;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONVIDEONATURALSIZECHANGE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONVIDEOOPACITYCHANGE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONSTATISTICSUPDATE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONAUDIOCONFIGCHANGE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_RC_ONVIDEOCONFIGCHANGE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_DS_INITIALIZE;
constexpr RpcMessage_RpcProc RpcMessage::RPC_DS_READUNTIL;
constexpr RpcMessage_RpcProc RpcMessage::RPC_DS_ENABLEBITSTREAMCONVERTER;
constexpr RpcMessage_RpcProc RpcMessage::RPC_DS_ONERROR;
constexpr RpcMessage_RpcProc RpcMessage::RPC_DS_INITIALIZE_CALLBACK;
constexpr RpcMessage_RpcProc RpcMessage::RPC_DS_READUNTIL_CALLBACK;
constexpr RpcMessage_RpcProc RpcMessage::RPC_DS_ENABLEBITSTREAMCONVERTER_CALLBACK;
constexpr RpcMessage_RpcProc RpcMessage::RpcProc_MIN;
constexpr RpcMessage_RpcProc RpcMessage::RpcProc_MAX;
constexpr int RpcMessage::RpcProc_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

// ===================================================================

class DecoderBuffer::_Internal {};

DecoderBuffer::DecoderBuffer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DecoderBuffer::DecoderBuffer(const DecoderBuffer& from)
  :{}

inline void DecoderBuffer::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DecoderBuffer::~DecoderBuffer() {}

inline void DecoderBuffer::SharedDtor() {}

void DecoderBuffer::SetCachedSize(int size) const {}

void DecoderBuffer::Clear() {}

const char* DecoderBuffer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DecoderBuffer::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DecoderBuffer::ByteSizeLong() const {}

void DecoderBuffer::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DecoderBuffer::MergeFrom(const DecoderBuffer& from) {}

void DecoderBuffer::CopyFrom(const DecoderBuffer& from) {}

bool DecoderBuffer::IsInitialized() const {}

void DecoderBuffer::InternalSwap(DecoderBuffer* other) {}

std::string DecoderBuffer::GetTypeName() const {}


// ===================================================================

class Size::_Internal {};

Size::Size(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
Size::Size(const Size& from)
  :{}

inline void Size::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

Size::~Size() {}

inline void Size::SharedDtor() {}

void Size::SetCachedSize(int size) const {}

void Size::Clear() {}

const char* Size::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* Size::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t Size::ByteSizeLong() const {}

void Size::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void Size::MergeFrom(const Size& from) {}

void Size::CopyFrom(const Size& from) {}

bool Size::IsInitialized() const {}

void Size::InternalSwap(Size* other) {}

std::string Size::GetTypeName() const {}


// ===================================================================

class AudioDecoderConfig::_Internal {};

AudioDecoderConfig::AudioDecoderConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AudioDecoderConfig::AudioDecoderConfig(const AudioDecoderConfig& from)
  :{}

inline void AudioDecoderConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AudioDecoderConfig::~AudioDecoderConfig() {}

inline void AudioDecoderConfig::SharedDtor() {}

void AudioDecoderConfig::SetCachedSize(int size) const {}

void AudioDecoderConfig::Clear() {}

const char* AudioDecoderConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AudioDecoderConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AudioDecoderConfig::ByteSizeLong() const {}

void AudioDecoderConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AudioDecoderConfig::MergeFrom(const AudioDecoderConfig& from) {}

void AudioDecoderConfig::CopyFrom(const AudioDecoderConfig& from) {}

bool AudioDecoderConfig::IsInitialized() const {}

void AudioDecoderConfig::InternalSwap(AudioDecoderConfig* other) {}

std::string AudioDecoderConfig::GetTypeName() const {}


// ===================================================================

class Rect::_Internal {};

Rect::Rect(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
Rect::Rect(const Rect& from)
  :{}

inline void Rect::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

Rect::~Rect() {}

inline void Rect::SharedDtor() {}

void Rect::SetCachedSize(int size) const {}

void Rect::Clear() {}

const char* Rect::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* Rect::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t Rect::ByteSizeLong() const {}

void Rect::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void Rect::MergeFrom(const Rect& from) {}

void Rect::CopyFrom(const Rect& from) {}

bool Rect::IsInitialized() const {}

void Rect::InternalSwap(Rect* other) {}

std::string Rect::GetTypeName() const {}


// ===================================================================

class VideoDecoderConfig::_Internal {};

const ::openscreen::cast::Size&
VideoDecoderConfig::_Internal::coded_size(const VideoDecoderConfig* msg) {}
const ::openscreen::cast::Rect&
VideoDecoderConfig::_Internal::visible_rect(const VideoDecoderConfig* msg) {}
const ::openscreen::cast::Size&
VideoDecoderConfig::_Internal::natural_size(const VideoDecoderConfig* msg) {}
VideoDecoderConfig::VideoDecoderConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
VideoDecoderConfig::VideoDecoderConfig(const VideoDecoderConfig& from)
  :{}

inline void VideoDecoderConfig::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

VideoDecoderConfig::~VideoDecoderConfig() {}

inline void VideoDecoderConfig::SharedDtor() {}

void VideoDecoderConfig::SetCachedSize(int size) const {}

void VideoDecoderConfig::Clear() {}

const char* VideoDecoderConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* VideoDecoderConfig::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t VideoDecoderConfig::ByteSizeLong() const {}

void VideoDecoderConfig::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void VideoDecoderConfig::MergeFrom(const VideoDecoderConfig& from) {}

void VideoDecoderConfig::CopyFrom(const VideoDecoderConfig& from) {}

bool VideoDecoderConfig::IsInitialized() const {}

void VideoDecoderConfig::InternalSwap(VideoDecoderConfig* other) {}

std::string VideoDecoderConfig::GetTypeName() const {}


// ===================================================================

class AudioDecoderInfo::_Internal {};

AudioDecoderInfo::AudioDecoderInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AudioDecoderInfo::AudioDecoderInfo(const AudioDecoderInfo& from)
  :{}

inline void AudioDecoderInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AudioDecoderInfo::~AudioDecoderInfo() {}

inline void AudioDecoderInfo::SharedDtor() {}

void AudioDecoderInfo::SetCachedSize(int size) const {}

void AudioDecoderInfo::Clear() {}

const char* AudioDecoderInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AudioDecoderInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AudioDecoderInfo::ByteSizeLong() const {}

void AudioDecoderInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AudioDecoderInfo::MergeFrom(const AudioDecoderInfo& from) {}

void AudioDecoderInfo::CopyFrom(const AudioDecoderInfo& from) {}

bool AudioDecoderInfo::IsInitialized() const {}

void AudioDecoderInfo::InternalSwap(AudioDecoderInfo* other) {}

std::string AudioDecoderInfo::GetTypeName() const {}


// ===================================================================

class VideoDecoderInfo::_Internal {};

VideoDecoderInfo::VideoDecoderInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
VideoDecoderInfo::VideoDecoderInfo(const VideoDecoderInfo& from)
  :{}

inline void VideoDecoderInfo::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

VideoDecoderInfo::~VideoDecoderInfo() {}

inline void VideoDecoderInfo::SharedDtor() {}

void VideoDecoderInfo::SetCachedSize(int size) const {}

void VideoDecoderInfo::Clear() {}

const char* VideoDecoderInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* VideoDecoderInfo::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t VideoDecoderInfo::ByteSizeLong() const {}

void VideoDecoderInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void VideoDecoderInfo::MergeFrom(const VideoDecoderInfo& from) {}

void VideoDecoderInfo::CopyFrom(const VideoDecoderInfo& from) {}

bool VideoDecoderInfo::IsInitialized() const {}

void VideoDecoderInfo::InternalSwap(VideoDecoderInfo* other) {}

std::string VideoDecoderInfo::GetTypeName() const {}


// ===================================================================

class PipelineStatistics::_Internal {};

const ::openscreen::cast::AudioDecoderInfo&
PipelineStatistics::_Internal::audio_decoder_info(const PipelineStatistics* msg) {}
const ::openscreen::cast::VideoDecoderInfo&
PipelineStatistics::_Internal::video_decoder_info(const PipelineStatistics* msg) {}
PipelineStatistics::PipelineStatistics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
PipelineStatistics::PipelineStatistics(const PipelineStatistics& from)
  :{}

inline void PipelineStatistics::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

PipelineStatistics::~PipelineStatistics() {}

inline void PipelineStatistics::SharedDtor() {}

void PipelineStatistics::SetCachedSize(int size) const {}

void PipelineStatistics::Clear() {}

const char* PipelineStatistics::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* PipelineStatistics::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t PipelineStatistics::ByteSizeLong() const {}

void PipelineStatistics::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void PipelineStatistics::MergeFrom(const PipelineStatistics& from) {}

void PipelineStatistics::CopyFrom(const PipelineStatistics& from) {}

bool PipelineStatistics::IsInitialized() const {}

void PipelineStatistics::InternalSwap(PipelineStatistics* other) {}

std::string PipelineStatistics::GetTypeName() const {}


// ===================================================================

class AcquireDemuxer::_Internal {};

AcquireDemuxer::AcquireDemuxer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
AcquireDemuxer::AcquireDemuxer(const AcquireDemuxer& from)
  :{}

inline void AcquireDemuxer::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

AcquireDemuxer::~AcquireDemuxer() {}

inline void AcquireDemuxer::SharedDtor() {}

void AcquireDemuxer::SetCachedSize(int size) const {}

void AcquireDemuxer::Clear() {}

const char* AcquireDemuxer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* AcquireDemuxer::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t AcquireDemuxer::ByteSizeLong() const {}

void AcquireDemuxer::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void AcquireDemuxer::MergeFrom(const AcquireDemuxer& from) {}

void AcquireDemuxer::CopyFrom(const AcquireDemuxer& from) {}

bool AcquireDemuxer::IsInitialized() const {}

void AcquireDemuxer::InternalSwap(AcquireDemuxer* other) {}

std::string AcquireDemuxer::GetTypeName() const {}


// ===================================================================

class RendererInitialize::_Internal {};

RendererInitialize::RendererInitialize(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RendererInitialize::RendererInitialize(const RendererInitialize& from)
  :{}

inline void RendererInitialize::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RendererInitialize::~RendererInitialize() {}

inline void RendererInitialize::SharedDtor() {}

void RendererInitialize::SetCachedSize(int size) const {}

void RendererInitialize::Clear() {}

const char* RendererInitialize::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RendererInitialize::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RendererInitialize::ByteSizeLong() const {}

void RendererInitialize::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RendererInitialize::MergeFrom(const RendererInitialize& from) {}

void RendererInitialize::CopyFrom(const RendererInitialize& from) {}

bool RendererInitialize::IsInitialized() const {}

void RendererInitialize::InternalSwap(RendererInitialize* other) {}

std::string RendererInitialize::GetTypeName() const {}


// ===================================================================

class RendererFlushUntil::_Internal {};

RendererFlushUntil::RendererFlushUntil(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RendererFlushUntil::RendererFlushUntil(const RendererFlushUntil& from)
  :{}

inline void RendererFlushUntil::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RendererFlushUntil::~RendererFlushUntil() {}

inline void RendererFlushUntil::SharedDtor() {}

void RendererFlushUntil::SetCachedSize(int size) const {}

void RendererFlushUntil::Clear() {}

const char* RendererFlushUntil::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RendererFlushUntil::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RendererFlushUntil::ByteSizeLong() const {}

void RendererFlushUntil::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RendererFlushUntil::MergeFrom(const RendererFlushUntil& from) {}

void RendererFlushUntil::CopyFrom(const RendererFlushUntil& from) {}

bool RendererFlushUntil::IsInitialized() const {}

void RendererFlushUntil::InternalSwap(RendererFlushUntil* other) {}

std::string RendererFlushUntil::GetTypeName() const {}


// ===================================================================

class RendererClientOnTimeUpdate::_Internal {};

RendererClientOnTimeUpdate::RendererClientOnTimeUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RendererClientOnTimeUpdate::RendererClientOnTimeUpdate(const RendererClientOnTimeUpdate& from)
  :{}

inline void RendererClientOnTimeUpdate::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RendererClientOnTimeUpdate::~RendererClientOnTimeUpdate() {}

inline void RendererClientOnTimeUpdate::SharedDtor() {}

void RendererClientOnTimeUpdate::SetCachedSize(int size) const {}

void RendererClientOnTimeUpdate::Clear() {}

const char* RendererClientOnTimeUpdate::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RendererClientOnTimeUpdate::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RendererClientOnTimeUpdate::ByteSizeLong() const {}

void RendererClientOnTimeUpdate::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RendererClientOnTimeUpdate::MergeFrom(const RendererClientOnTimeUpdate& from) {}

void RendererClientOnTimeUpdate::CopyFrom(const RendererClientOnTimeUpdate& from) {}

bool RendererClientOnTimeUpdate::IsInitialized() const {}

void RendererClientOnTimeUpdate::InternalSwap(RendererClientOnTimeUpdate* other) {}

std::string RendererClientOnTimeUpdate::GetTypeName() const {}


// ===================================================================

class RendererClientOnBufferingStateChange::_Internal {};

RendererClientOnBufferingStateChange::RendererClientOnBufferingStateChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RendererClientOnBufferingStateChange::RendererClientOnBufferingStateChange(const RendererClientOnBufferingStateChange& from)
  :{}

inline void RendererClientOnBufferingStateChange::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RendererClientOnBufferingStateChange::~RendererClientOnBufferingStateChange() {}

inline void RendererClientOnBufferingStateChange::SharedDtor() {}

void RendererClientOnBufferingStateChange::SetCachedSize(int size) const {}

void RendererClientOnBufferingStateChange::Clear() {}

const char* RendererClientOnBufferingStateChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RendererClientOnBufferingStateChange::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RendererClientOnBufferingStateChange::ByteSizeLong() const {}

void RendererClientOnBufferingStateChange::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RendererClientOnBufferingStateChange::MergeFrom(const RendererClientOnBufferingStateChange& from) {}

void RendererClientOnBufferingStateChange::CopyFrom(const RendererClientOnBufferingStateChange& from) {}

bool RendererClientOnBufferingStateChange::IsInitialized() const {}

void RendererClientOnBufferingStateChange::InternalSwap(RendererClientOnBufferingStateChange* other) {}

std::string RendererClientOnBufferingStateChange::GetTypeName() const {}


// ===================================================================

class RendererClientOnAudioConfigChange::_Internal {};

const ::openscreen::cast::AudioDecoderConfig&
RendererClientOnAudioConfigChange::_Internal::audio_decoder_config(const RendererClientOnAudioConfigChange* msg) {}
RendererClientOnAudioConfigChange::RendererClientOnAudioConfigChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RendererClientOnAudioConfigChange::RendererClientOnAudioConfigChange(const RendererClientOnAudioConfigChange& from)
  :{}

inline void RendererClientOnAudioConfigChange::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RendererClientOnAudioConfigChange::~RendererClientOnAudioConfigChange() {}

inline void RendererClientOnAudioConfigChange::SharedDtor() {}

void RendererClientOnAudioConfigChange::SetCachedSize(int size) const {}

void RendererClientOnAudioConfigChange::Clear() {}

const char* RendererClientOnAudioConfigChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RendererClientOnAudioConfigChange::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RendererClientOnAudioConfigChange::ByteSizeLong() const {}

void RendererClientOnAudioConfigChange::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RendererClientOnAudioConfigChange::MergeFrom(const RendererClientOnAudioConfigChange& from) {}

void RendererClientOnAudioConfigChange::CopyFrom(const RendererClientOnAudioConfigChange& from) {}

bool RendererClientOnAudioConfigChange::IsInitialized() const {}

void RendererClientOnAudioConfigChange::InternalSwap(RendererClientOnAudioConfigChange* other) {}

std::string RendererClientOnAudioConfigChange::GetTypeName() const {}


// ===================================================================

class RendererClientOnVideoConfigChange::_Internal {};

const ::openscreen::cast::VideoDecoderConfig&
RendererClientOnVideoConfigChange::_Internal::video_decoder_config(const RendererClientOnVideoConfigChange* msg) {}
RendererClientOnVideoConfigChange::RendererClientOnVideoConfigChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RendererClientOnVideoConfigChange::RendererClientOnVideoConfigChange(const RendererClientOnVideoConfigChange& from)
  :{}

inline void RendererClientOnVideoConfigChange::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RendererClientOnVideoConfigChange::~RendererClientOnVideoConfigChange() {}

inline void RendererClientOnVideoConfigChange::SharedDtor() {}

void RendererClientOnVideoConfigChange::SetCachedSize(int size) const {}

void RendererClientOnVideoConfigChange::Clear() {}

const char* RendererClientOnVideoConfigChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RendererClientOnVideoConfigChange::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RendererClientOnVideoConfigChange::ByteSizeLong() const {}

void RendererClientOnVideoConfigChange::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RendererClientOnVideoConfigChange::MergeFrom(const RendererClientOnVideoConfigChange& from) {}

void RendererClientOnVideoConfigChange::CopyFrom(const RendererClientOnVideoConfigChange& from) {}

bool RendererClientOnVideoConfigChange::IsInitialized() const {}

void RendererClientOnVideoConfigChange::InternalSwap(RendererClientOnVideoConfigChange* other) {}

std::string RendererClientOnVideoConfigChange::GetTypeName() const {}


// ===================================================================

class RemotingError::_Internal {};

RemotingError::RemotingError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RemotingError::RemotingError(const RemotingError& from)
  :{}

inline void RemotingError::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RemotingError::~RemotingError() {}

inline void RemotingError::SharedDtor() {}

void RemotingError::SetCachedSize(int size) const {}

void RemotingError::Clear() {}

const char* RemotingError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RemotingError::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RemotingError::ByteSizeLong() const {}

void RemotingError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RemotingError::MergeFrom(const RemotingError& from) {}

void RemotingError::CopyFrom(const RemotingError& from) {}

bool RemotingError::IsInitialized() const {}

void RemotingError::InternalSwap(RemotingError* other) {}

std::string RemotingError::GetTypeName() const {}


// ===================================================================

class DemuxerStreamReadUntil::_Internal {};

DemuxerStreamReadUntil::DemuxerStreamReadUntil(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DemuxerStreamReadUntil::DemuxerStreamReadUntil(const DemuxerStreamReadUntil& from)
  :{}

inline void DemuxerStreamReadUntil::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DemuxerStreamReadUntil::~DemuxerStreamReadUntil() {}

inline void DemuxerStreamReadUntil::SharedDtor() {}

void DemuxerStreamReadUntil::SetCachedSize(int size) const {}

void DemuxerStreamReadUntil::Clear() {}

const char* DemuxerStreamReadUntil::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DemuxerStreamReadUntil::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DemuxerStreamReadUntil::ByteSizeLong() const {}

void DemuxerStreamReadUntil::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DemuxerStreamReadUntil::MergeFrom(const DemuxerStreamReadUntil& from) {}

void DemuxerStreamReadUntil::CopyFrom(const DemuxerStreamReadUntil& from) {}

bool DemuxerStreamReadUntil::IsInitialized() const {}

void DemuxerStreamReadUntil::InternalSwap(DemuxerStreamReadUntil* other) {}

std::string DemuxerStreamReadUntil::GetTypeName() const {}


// ===================================================================

class DemuxerStreamInitializeCallback::_Internal {};

const ::openscreen::cast::AudioDecoderConfig&
DemuxerStreamInitializeCallback::_Internal::audio_decoder_config(const DemuxerStreamInitializeCallback* msg) {}
const ::openscreen::cast::VideoDecoderConfig&
DemuxerStreamInitializeCallback::_Internal::video_decoder_config(const DemuxerStreamInitializeCallback* msg) {}
DemuxerStreamInitializeCallback::DemuxerStreamInitializeCallback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DemuxerStreamInitializeCallback::DemuxerStreamInitializeCallback(const DemuxerStreamInitializeCallback& from)
  :{}

inline void DemuxerStreamInitializeCallback::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DemuxerStreamInitializeCallback::~DemuxerStreamInitializeCallback() {}

inline void DemuxerStreamInitializeCallback::SharedDtor() {}

void DemuxerStreamInitializeCallback::SetCachedSize(int size) const {}

void DemuxerStreamInitializeCallback::Clear() {}

const char* DemuxerStreamInitializeCallback::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DemuxerStreamInitializeCallback::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DemuxerStreamInitializeCallback::ByteSizeLong() const {}

void DemuxerStreamInitializeCallback::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DemuxerStreamInitializeCallback::MergeFrom(const DemuxerStreamInitializeCallback& from) {}

void DemuxerStreamInitializeCallback::CopyFrom(const DemuxerStreamInitializeCallback& from) {}

bool DemuxerStreamInitializeCallback::IsInitialized() const {}

void DemuxerStreamInitializeCallback::InternalSwap(DemuxerStreamInitializeCallback* other) {}

std::string DemuxerStreamInitializeCallback::GetTypeName() const {}


// ===================================================================

class DemuxerStreamReadUntilCallback::_Internal {};

const ::openscreen::cast::AudioDecoderConfig&
DemuxerStreamReadUntilCallback::_Internal::audio_decoder_config(const DemuxerStreamReadUntilCallback* msg) {}
const ::openscreen::cast::VideoDecoderConfig&
DemuxerStreamReadUntilCallback::_Internal::video_decoder_config(const DemuxerStreamReadUntilCallback* msg) {}
DemuxerStreamReadUntilCallback::DemuxerStreamReadUntilCallback(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
DemuxerStreamReadUntilCallback::DemuxerStreamReadUntilCallback(const DemuxerStreamReadUntilCallback& from)
  :{}

inline void DemuxerStreamReadUntilCallback::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

DemuxerStreamReadUntilCallback::~DemuxerStreamReadUntilCallback() {}

inline void DemuxerStreamReadUntilCallback::SharedDtor() {}

void DemuxerStreamReadUntilCallback::SetCachedSize(int size) const {}

void DemuxerStreamReadUntilCallback::Clear() {}

const char* DemuxerStreamReadUntilCallback::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* DemuxerStreamReadUntilCallback::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t DemuxerStreamReadUntilCallback::ByteSizeLong() const {}

void DemuxerStreamReadUntilCallback::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void DemuxerStreamReadUntilCallback::MergeFrom(const DemuxerStreamReadUntilCallback& from) {}

void DemuxerStreamReadUntilCallback::CopyFrom(const DemuxerStreamReadUntilCallback& from) {}

bool DemuxerStreamReadUntilCallback::IsInitialized() const {}

void DemuxerStreamReadUntilCallback::InternalSwap(DemuxerStreamReadUntilCallback* other) {}

std::string DemuxerStreamReadUntilCallback::GetTypeName() const {}


// ===================================================================

class RpcMessage::_Internal {};

const ::openscreen::cast::RemotingError&
RpcMessage::_Internal::remoting_error_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::RendererInitialize&
RpcMessage::_Internal::renderer_initialize_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::RendererFlushUntil&
RpcMessage::_Internal::renderer_flushuntil_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::AcquireDemuxer&
RpcMessage::_Internal::acquire_demuxer_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::RendererClientOnTimeUpdate&
RpcMessage::_Internal::rendererclient_ontimeupdate_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::Size&
RpcMessage::_Internal::rendererclient_onvideonatualsizechange_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::PipelineStatistics&
RpcMessage::_Internal::rendererclient_onstatisticsupdate_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::RendererClientOnBufferingStateChange&
RpcMessage::_Internal::rendererclient_onbufferingstatechange_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::RendererClientOnAudioConfigChange&
RpcMessage::_Internal::rendererclient_onaudioconfigchange_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::RendererClientOnVideoConfigChange&
RpcMessage::_Internal::rendererclient_onvideoconfigchange_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::DemuxerStreamReadUntil&
RpcMessage::_Internal::demuxerstream_readuntil_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::DemuxerStreamInitializeCallback&
RpcMessage::_Internal::demuxerstream_initializecb_rpc(const RpcMessage* msg) {}
const ::openscreen::cast::DemuxerStreamReadUntilCallback&
RpcMessage::_Internal::demuxerstream_readuntilcb_rpc(const RpcMessage* msg) {}
void RpcMessage::set_allocated_remoting_error_rpc(::openscreen::cast::RemotingError* remoting_error_rpc) {}
void RpcMessage::set_allocated_renderer_initialize_rpc(::openscreen::cast::RendererInitialize* renderer_initialize_rpc) {}
void RpcMessage::set_allocated_renderer_flushuntil_rpc(::openscreen::cast::RendererFlushUntil* renderer_flushuntil_rpc) {}
void RpcMessage::set_allocated_acquire_demuxer_rpc(::openscreen::cast::AcquireDemuxer* acquire_demuxer_rpc) {}
void RpcMessage::set_allocated_rendererclient_ontimeupdate_rpc(::openscreen::cast::RendererClientOnTimeUpdate* rendererclient_ontimeupdate_rpc) {}
void RpcMessage::set_allocated_rendererclient_onvideonatualsizechange_rpc(::openscreen::cast::Size* rendererclient_onvideonatualsizechange_rpc) {}
void RpcMessage::set_allocated_rendererclient_onstatisticsupdate_rpc(::openscreen::cast::PipelineStatistics* rendererclient_onstatisticsupdate_rpc) {}
void RpcMessage::set_allocated_rendererclient_onbufferingstatechange_rpc(::openscreen::cast::RendererClientOnBufferingStateChange* rendererclient_onbufferingstatechange_rpc) {}
void RpcMessage::set_allocated_rendererclient_onaudioconfigchange_rpc(::openscreen::cast::RendererClientOnAudioConfigChange* rendererclient_onaudioconfigchange_rpc) {}
void RpcMessage::set_allocated_rendererclient_onvideoconfigchange_rpc(::openscreen::cast::RendererClientOnVideoConfigChange* rendererclient_onvideoconfigchange_rpc) {}
void RpcMessage::set_allocated_demuxerstream_readuntil_rpc(::openscreen::cast::DemuxerStreamReadUntil* demuxerstream_readuntil_rpc) {}
void RpcMessage::set_allocated_demuxerstream_initializecb_rpc(::openscreen::cast::DemuxerStreamInitializeCallback* demuxerstream_initializecb_rpc) {}
void RpcMessage::set_allocated_demuxerstream_readuntilcb_rpc(::openscreen::cast::DemuxerStreamReadUntilCallback* demuxerstream_readuntilcb_rpc) {}
RpcMessage::RpcMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  :{}
RpcMessage::RpcMessage(const RpcMessage& from)
  :{}

inline void RpcMessage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {}

RpcMessage::~RpcMessage() {}

inline void RpcMessage::SharedDtor() {}

void RpcMessage::SetCachedSize(int size) const {}

void RpcMessage::clear_rpc_oneof() {}


void RpcMessage::Clear() {}

const char* RpcMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {}

uint8_t* RpcMessage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {}

size_t RpcMessage::ByteSizeLong() const {}

void RpcMessage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {}

void RpcMessage::MergeFrom(const RpcMessage& from) {}

void RpcMessage::CopyFrom(const RpcMessage& from) {}

bool RpcMessage::IsInitialized() const {}

void RpcMessage::InternalSwap(RpcMessage* other) {}

std::string RpcMessage::GetTypeName() const {}


// @@protoc_insertion_point(namespace_scope)
}  // namespace cast
}  // namespace openscreen
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::openscreen::cast::DecoderBuffer*
Arena::CreateMaybeMessage< ::openscreen::cast::DecoderBuffer >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::Size*
Arena::CreateMaybeMessage< ::openscreen::cast::Size >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::AudioDecoderConfig*
Arena::CreateMaybeMessage< ::openscreen::cast::AudioDecoderConfig >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::Rect*
Arena::CreateMaybeMessage< ::openscreen::cast::Rect >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::VideoDecoderConfig*
Arena::CreateMaybeMessage< ::openscreen::cast::VideoDecoderConfig >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::AudioDecoderInfo*
Arena::CreateMaybeMessage< ::openscreen::cast::AudioDecoderInfo >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::VideoDecoderInfo*
Arena::CreateMaybeMessage< ::openscreen::cast::VideoDecoderInfo >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::PipelineStatistics*
Arena::CreateMaybeMessage< ::openscreen::cast::PipelineStatistics >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::AcquireDemuxer*
Arena::CreateMaybeMessage< ::openscreen::cast::AcquireDemuxer >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RendererInitialize*
Arena::CreateMaybeMessage< ::openscreen::cast::RendererInitialize >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RendererFlushUntil*
Arena::CreateMaybeMessage< ::openscreen::cast::RendererFlushUntil >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RendererClientOnTimeUpdate*
Arena::CreateMaybeMessage< ::openscreen::cast::RendererClientOnTimeUpdate >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RendererClientOnBufferingStateChange*
Arena::CreateMaybeMessage< ::openscreen::cast::RendererClientOnBufferingStateChange >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RendererClientOnAudioConfigChange*
Arena::CreateMaybeMessage< ::openscreen::cast::RendererClientOnAudioConfigChange >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RendererClientOnVideoConfigChange*
Arena::CreateMaybeMessage< ::openscreen::cast::RendererClientOnVideoConfigChange >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RemotingError*
Arena::CreateMaybeMessage< ::openscreen::cast::RemotingError >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::DemuxerStreamReadUntil*
Arena::CreateMaybeMessage< ::openscreen::cast::DemuxerStreamReadUntil >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::DemuxerStreamInitializeCallback*
Arena::CreateMaybeMessage< ::openscreen::cast::DemuxerStreamInitializeCallback >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::DemuxerStreamReadUntilCallback*
Arena::CreateMaybeMessage< ::openscreen::cast::DemuxerStreamReadUntilCallback >(Arena* arena) {}
template<> PROTOBUF_NOINLINE ::openscreen::cast::RpcMessage*
Arena::CreateMaybeMessage< ::openscreen::cast::RpcMessage >(Arena* arena) {}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>