1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: debug.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_debug_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_debug_2eproto
6
7 #include <limits>
8 #include <string>
9
10 #include <google/protobuf/port_def.inc>
11 #if PROTOBUF_VERSION < 3020000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers. Please update
14 #error your headers.
15 #endif
16 #if 3020000 < PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers. Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21
22 #include <google/protobuf/port_undef.inc>
23 #include <google/protobuf/io/coded_stream.h>
24 #include <google/protobuf/arena.h>
25 #include <google/protobuf/arenastring.h>
26 #include <google/protobuf/generated_message_util.h>
27 #include <google/protobuf/metadata_lite.h>
28 #include <google/protobuf/message_lite.h>
29 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
30 #include <google/protobuf/extension_set.h> // IWYU pragma: export
31 #include <google/protobuf/generated_enum_util.h>
32 // @@protoc_insertion_point(includes)
33 #include <google/protobuf/port_def.inc>
34 #define PROTOBUF_INTERNAL_EXPORT_debug_2eproto
35 PROTOBUF_NAMESPACE_OPEN
36 namespace internal {
37 class AnyMetadata;
38 } // namespace internal
39 PROTOBUF_NAMESPACE_CLOSE
40
41 // Internal implementation detail -- do not use these members.
42 struct TableStruct_debug_2eproto {
43 static const uint32_t offsets[];
44 };
45 namespace webrtc {
46 namespace audioproc {
47 class Config;
48 struct ConfigDefaultTypeInternal;
49 extern ConfigDefaultTypeInternal _Config_default_instance_;
50 class Event;
51 struct EventDefaultTypeInternal;
52 extern EventDefaultTypeInternal _Event_default_instance_;
53 class Init;
54 struct InitDefaultTypeInternal;
55 extern InitDefaultTypeInternal _Init_default_instance_;
56 class PlayoutAudioDeviceInfo;
57 struct PlayoutAudioDeviceInfoDefaultTypeInternal;
58 extern PlayoutAudioDeviceInfoDefaultTypeInternal _PlayoutAudioDeviceInfo_default_instance_;
59 class ReverseStream;
60 struct ReverseStreamDefaultTypeInternal;
61 extern ReverseStreamDefaultTypeInternal _ReverseStream_default_instance_;
62 class RuntimeSetting;
63 struct RuntimeSettingDefaultTypeInternal;
64 extern RuntimeSettingDefaultTypeInternal _RuntimeSetting_default_instance_;
65 class Stream;
66 struct StreamDefaultTypeInternal;
67 extern StreamDefaultTypeInternal _Stream_default_instance_;
68 } // namespace audioproc
69 } // namespace webrtc
70 PROTOBUF_NAMESPACE_OPEN
71 template<> ::webrtc::audioproc::Config* Arena::CreateMaybeMessage<::webrtc::audioproc::Config>(Arena*);
72 template<> ::webrtc::audioproc::Event* Arena::CreateMaybeMessage<::webrtc::audioproc::Event>(Arena*);
73 template<> ::webrtc::audioproc::Init* Arena::CreateMaybeMessage<::webrtc::audioproc::Init>(Arena*);
74 template<> ::webrtc::audioproc::PlayoutAudioDeviceInfo* Arena::CreateMaybeMessage<::webrtc::audioproc::PlayoutAudioDeviceInfo>(Arena*);
75 template<> ::webrtc::audioproc::ReverseStream* Arena::CreateMaybeMessage<::webrtc::audioproc::ReverseStream>(Arena*);
76 template<> ::webrtc::audioproc::RuntimeSetting* Arena::CreateMaybeMessage<::webrtc::audioproc::RuntimeSetting>(Arena*);
77 template<> ::webrtc::audioproc::Stream* Arena::CreateMaybeMessage<::webrtc::audioproc::Stream>(Arena*);
78 PROTOBUF_NAMESPACE_CLOSE
79 namespace webrtc {
80 namespace audioproc {
81
82 enum Event_Type : int {
83 Event_Type_INIT = 0,
84 Event_Type_REVERSE_STREAM = 1,
85 Event_Type_STREAM = 2,
86 Event_Type_CONFIG = 3,
87 Event_Type_UNKNOWN_EVENT = 4,
88 Event_Type_RUNTIME_SETTING = 5
89 };
90 bool Event_Type_IsValid(int value);
91 constexpr Event_Type Event_Type_Type_MIN = Event_Type_INIT;
92 constexpr Event_Type Event_Type_Type_MAX = Event_Type_RUNTIME_SETTING;
93 constexpr int Event_Type_Type_ARRAYSIZE = Event_Type_Type_MAX + 1;
94
95 const std::string& Event_Type_Name(Event_Type value);
96 template<typename T>
Event_Type_Name(T enum_t_value)97 inline const std::string& Event_Type_Name(T enum_t_value) {
98 static_assert(::std::is_same<T, Event_Type>::value ||
99 ::std::is_integral<T>::value,
100 "Incorrect type passed to function Event_Type_Name.");
101 return Event_Type_Name(static_cast<Event_Type>(enum_t_value));
102 }
103 bool Event_Type_Parse(
104 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Event_Type* value);
105 // ===================================================================
106
107 class Init final :
108 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Init) */ {
109 public:
Init()110 inline Init() : Init(nullptr) {}
111 ~Init() override;
112 explicit PROTOBUF_CONSTEXPR Init(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
113
114 Init(const Init& from);
Init(Init && from)115 Init(Init&& from) noexcept
116 : Init() {
117 *this = ::std::move(from);
118 }
119
120 inline Init& operator=(const Init& from) {
121 CopyFrom(from);
122 return *this;
123 }
124 inline Init& operator=(Init&& from) noexcept {
125 if (this == &from) return *this;
126 if (GetOwningArena() == from.GetOwningArena()
127 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
128 && GetOwningArena() != nullptr
129 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
130 ) {
131 InternalSwap(&from);
132 } else {
133 CopyFrom(from);
134 }
135 return *this;
136 }
137
unknown_fields()138 inline const std::string& unknown_fields() const {
139 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
140 }
mutable_unknown_fields()141 inline std::string* mutable_unknown_fields() {
142 return _internal_metadata_.mutable_unknown_fields<std::string>();
143 }
144
default_instance()145 static const Init& default_instance() {
146 return *internal_default_instance();
147 }
internal_default_instance()148 static inline const Init* internal_default_instance() {
149 return reinterpret_cast<const Init*>(
150 &_Init_default_instance_);
151 }
152 static constexpr int kIndexInFileMessages =
153 0;
154
swap(Init & a,Init & b)155 friend void swap(Init& a, Init& b) {
156 a.Swap(&b);
157 }
Swap(Init * other)158 PROTOBUF_NOINLINE void Swap(Init* other) {
159 if (other == this) return;
160 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
161 if (GetOwningArena() != nullptr &&
162 GetOwningArena() == other->GetOwningArena()) {
163 #else // PROTOBUF_FORCE_COPY_IN_SWAP
164 if (GetOwningArena() == other->GetOwningArena()) {
165 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
166 InternalSwap(other);
167 } else {
168 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
169 }
170 }
171 void UnsafeArenaSwap(Init* other) {
172 if (other == this) return;
173 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
174 InternalSwap(other);
175 }
176
177 // implements Message ----------------------------------------------
178
179 Init* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
180 return CreateMaybeMessage<Init>(arena);
181 }
182 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
183 void CopyFrom(const Init& from);
184 void MergeFrom(const Init& from);
185 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
186 bool IsInitialized() const final;
187
188 size_t ByteSizeLong() const final;
189 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
190 uint8_t* _InternalSerialize(
191 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
192 int GetCachedSize() const final { return _cached_size_.Get(); }
193
194 private:
195 void SharedCtor();
196 void SharedDtor();
197 void SetCachedSize(int size) const;
198 void InternalSwap(Init* other);
199
200 private:
201 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
202 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
203 return "webrtc.audioproc.Init";
204 }
205 protected:
206 explicit Init(::PROTOBUF_NAMESPACE_ID::Arena* arena,
207 bool is_message_owned = false);
208 public:
209
210 std::string GetTypeName() const final;
211
212 // nested types ----------------------------------------------------
213
214 // accessors -------------------------------------------------------
215
216 enum : int {
217 kSampleRateFieldNumber = 1,
218 kDeviceSampleRateFieldNumber = 2,
219 kNumInputChannelsFieldNumber = 3,
220 kNumOutputChannelsFieldNumber = 4,
221 kNumReverseChannelsFieldNumber = 5,
222 kReverseSampleRateFieldNumber = 6,
223 kOutputSampleRateFieldNumber = 7,
224 kReverseOutputSampleRateFieldNumber = 8,
225 kTimestampMsFieldNumber = 10,
226 kNumReverseOutputChannelsFieldNumber = 9,
227 };
228 // optional int32 sample_rate = 1;
229 bool has_sample_rate() const;
230 private:
231 bool _internal_has_sample_rate() const;
232 public:
233 void clear_sample_rate();
234 int32_t sample_rate() const;
235 void set_sample_rate(int32_t value);
236 private:
237 int32_t _internal_sample_rate() const;
238 void _internal_set_sample_rate(int32_t value);
239 public:
240
241 // optional int32 device_sample_rate = 2 [deprecated = true];
242 PROTOBUF_DEPRECATED bool has_device_sample_rate() const;
243 private:
244 bool _internal_has_device_sample_rate() const;
245 public:
246 PROTOBUF_DEPRECATED void clear_device_sample_rate();
247 PROTOBUF_DEPRECATED int32_t device_sample_rate() const;
248 PROTOBUF_DEPRECATED void set_device_sample_rate(int32_t value);
249 private:
250 int32_t _internal_device_sample_rate() const;
251 void _internal_set_device_sample_rate(int32_t value);
252 public:
253
254 // optional int32 num_input_channels = 3;
255 bool has_num_input_channels() const;
256 private:
257 bool _internal_has_num_input_channels() const;
258 public:
259 void clear_num_input_channels();
260 int32_t num_input_channels() const;
261 void set_num_input_channels(int32_t value);
262 private:
263 int32_t _internal_num_input_channels() const;
264 void _internal_set_num_input_channels(int32_t value);
265 public:
266
267 // optional int32 num_output_channels = 4;
268 bool has_num_output_channels() const;
269 private:
270 bool _internal_has_num_output_channels() const;
271 public:
272 void clear_num_output_channels();
273 int32_t num_output_channels() const;
274 void set_num_output_channels(int32_t value);
275 private:
276 int32_t _internal_num_output_channels() const;
277 void _internal_set_num_output_channels(int32_t value);
278 public:
279
280 // optional int32 num_reverse_channels = 5;
281 bool has_num_reverse_channels() const;
282 private:
283 bool _internal_has_num_reverse_channels() const;
284 public:
285 void clear_num_reverse_channels();
286 int32_t num_reverse_channels() const;
287 void set_num_reverse_channels(int32_t value);
288 private:
289 int32_t _internal_num_reverse_channels() const;
290 void _internal_set_num_reverse_channels(int32_t value);
291 public:
292
293 // optional int32 reverse_sample_rate = 6;
294 bool has_reverse_sample_rate() const;
295 private:
296 bool _internal_has_reverse_sample_rate() const;
297 public:
298 void clear_reverse_sample_rate();
299 int32_t reverse_sample_rate() const;
300 void set_reverse_sample_rate(int32_t value);
301 private:
302 int32_t _internal_reverse_sample_rate() const;
303 void _internal_set_reverse_sample_rate(int32_t value);
304 public:
305
306 // optional int32 output_sample_rate = 7;
307 bool has_output_sample_rate() const;
308 private:
309 bool _internal_has_output_sample_rate() const;
310 public:
311 void clear_output_sample_rate();
312 int32_t output_sample_rate() const;
313 void set_output_sample_rate(int32_t value);
314 private:
315 int32_t _internal_output_sample_rate() const;
316 void _internal_set_output_sample_rate(int32_t value);
317 public:
318
319 // optional int32 reverse_output_sample_rate = 8;
320 bool has_reverse_output_sample_rate() const;
321 private:
322 bool _internal_has_reverse_output_sample_rate() const;
323 public:
324 void clear_reverse_output_sample_rate();
325 int32_t reverse_output_sample_rate() const;
326 void set_reverse_output_sample_rate(int32_t value);
327 private:
328 int32_t _internal_reverse_output_sample_rate() const;
329 void _internal_set_reverse_output_sample_rate(int32_t value);
330 public:
331
332 // optional int64 timestamp_ms = 10;
333 bool has_timestamp_ms() const;
334 private:
335 bool _internal_has_timestamp_ms() const;
336 public:
337 void clear_timestamp_ms();
338 int64_t timestamp_ms() const;
339 void set_timestamp_ms(int64_t value);
340 private:
341 int64_t _internal_timestamp_ms() const;
342 void _internal_set_timestamp_ms(int64_t value);
343 public:
344
345 // optional int32 num_reverse_output_channels = 9;
346 bool has_num_reverse_output_channels() const;
347 private:
348 bool _internal_has_num_reverse_output_channels() const;
349 public:
350 void clear_num_reverse_output_channels();
351 int32_t num_reverse_output_channels() const;
352 void set_num_reverse_output_channels(int32_t value);
353 private:
354 int32_t _internal_num_reverse_output_channels() const;
355 void _internal_set_num_reverse_output_channels(int32_t value);
356 public:
357
358 // @@protoc_insertion_point(class_scope:webrtc.audioproc.Init)
359 private:
360 class _Internal;
361
362 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
363 typedef void InternalArenaConstructable_;
364 typedef void DestructorSkippable_;
365 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
366 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
367 int32_t sample_rate_;
368 int32_t device_sample_rate_;
369 int32_t num_input_channels_;
370 int32_t num_output_channels_;
371 int32_t num_reverse_channels_;
372 int32_t reverse_sample_rate_;
373 int32_t output_sample_rate_;
374 int32_t reverse_output_sample_rate_;
375 int64_t timestamp_ms_;
376 int32_t num_reverse_output_channels_;
377 friend struct ::TableStruct_debug_2eproto;
378 };
379 // -------------------------------------------------------------------
380
381 class ReverseStream final :
382 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.ReverseStream) */ {
383 public:
ReverseStream()384 inline ReverseStream() : ReverseStream(nullptr) {}
385 ~ReverseStream() override;
386 explicit PROTOBUF_CONSTEXPR ReverseStream(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
387
388 ReverseStream(const ReverseStream& from);
ReverseStream(ReverseStream && from)389 ReverseStream(ReverseStream&& from) noexcept
390 : ReverseStream() {
391 *this = ::std::move(from);
392 }
393
394 inline ReverseStream& operator=(const ReverseStream& from) {
395 CopyFrom(from);
396 return *this;
397 }
398 inline ReverseStream& operator=(ReverseStream&& from) noexcept {
399 if (this == &from) return *this;
400 if (GetOwningArena() == from.GetOwningArena()
401 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
402 && GetOwningArena() != nullptr
403 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
404 ) {
405 InternalSwap(&from);
406 } else {
407 CopyFrom(from);
408 }
409 return *this;
410 }
411
unknown_fields()412 inline const std::string& unknown_fields() const {
413 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
414 }
mutable_unknown_fields()415 inline std::string* mutable_unknown_fields() {
416 return _internal_metadata_.mutable_unknown_fields<std::string>();
417 }
418
default_instance()419 static const ReverseStream& default_instance() {
420 return *internal_default_instance();
421 }
internal_default_instance()422 static inline const ReverseStream* internal_default_instance() {
423 return reinterpret_cast<const ReverseStream*>(
424 &_ReverseStream_default_instance_);
425 }
426 static constexpr int kIndexInFileMessages =
427 1;
428
swap(ReverseStream & a,ReverseStream & b)429 friend void swap(ReverseStream& a, ReverseStream& b) {
430 a.Swap(&b);
431 }
Swap(ReverseStream * other)432 PROTOBUF_NOINLINE void Swap(ReverseStream* other) {
433 if (other == this) return;
434 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
435 if (GetOwningArena() != nullptr &&
436 GetOwningArena() == other->GetOwningArena()) {
437 #else // PROTOBUF_FORCE_COPY_IN_SWAP
438 if (GetOwningArena() == other->GetOwningArena()) {
439 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
440 InternalSwap(other);
441 } else {
442 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
443 }
444 }
445 void UnsafeArenaSwap(ReverseStream* other) {
446 if (other == this) return;
447 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
448 InternalSwap(other);
449 }
450
451 // implements Message ----------------------------------------------
452
453 ReverseStream* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
454 return CreateMaybeMessage<ReverseStream>(arena);
455 }
456 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
457 void CopyFrom(const ReverseStream& from);
458 void MergeFrom(const ReverseStream& from);
459 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
460 bool IsInitialized() const final;
461
462 size_t ByteSizeLong() const final;
463 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
464 uint8_t* _InternalSerialize(
465 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
466 int GetCachedSize() const final { return _cached_size_.Get(); }
467
468 private:
469 void SharedCtor();
470 void SharedDtor();
471 void SetCachedSize(int size) const;
472 void InternalSwap(ReverseStream* other);
473
474 private:
475 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
476 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
477 return "webrtc.audioproc.ReverseStream";
478 }
479 protected:
480 explicit ReverseStream(::PROTOBUF_NAMESPACE_ID::Arena* arena,
481 bool is_message_owned = false);
482 public:
483
484 std::string GetTypeName() const final;
485
486 // nested types ----------------------------------------------------
487
488 // accessors -------------------------------------------------------
489
490 enum : int {
491 kChannelFieldNumber = 2,
492 kDataFieldNumber = 1,
493 };
494 // repeated bytes channel = 2;
495 int channel_size() const;
496 private:
497 int _internal_channel_size() const;
498 public:
499 void clear_channel();
500 const std::string& channel(int index) const;
501 std::string* mutable_channel(int index);
502 void set_channel(int index, const std::string& value);
503 void set_channel(int index, std::string&& value);
504 void set_channel(int index, const char* value);
505 void set_channel(int index, const void* value, size_t size);
506 std::string* add_channel();
507 void add_channel(const std::string& value);
508 void add_channel(std::string&& value);
509 void add_channel(const char* value);
510 void add_channel(const void* value, size_t size);
511 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& channel() const;
512 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_channel();
513 private:
514 const std::string& _internal_channel(int index) const;
515 std::string* _internal_add_channel();
516 public:
517
518 // optional bytes data = 1;
519 bool has_data() const;
520 private:
521 bool _internal_has_data() const;
522 public:
523 void clear_data();
524 const std::string& data() const;
525 template <typename ArgT0 = const std::string&, typename... ArgT>
526 void set_data(ArgT0&& arg0, ArgT... args);
527 std::string* mutable_data();
528 PROTOBUF_NODISCARD std::string* release_data();
529 void set_allocated_data(std::string* data);
530 private:
531 const std::string& _internal_data() const;
532 inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
533 std::string* _internal_mutable_data();
534 public:
535
536 // @@protoc_insertion_point(class_scope:webrtc.audioproc.ReverseStream)
537 private:
538 class _Internal;
539
540 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
541 typedef void InternalArenaConstructable_;
542 typedef void DestructorSkippable_;
543 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
544 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
545 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> channel_;
546 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
547 friend struct ::TableStruct_debug_2eproto;
548 };
549 // -------------------------------------------------------------------
550
551 class Stream final :
552 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Stream) */ {
553 public:
Stream()554 inline Stream() : Stream(nullptr) {}
555 ~Stream() override;
556 explicit PROTOBUF_CONSTEXPR Stream(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
557
558 Stream(const Stream& from);
Stream(Stream && from)559 Stream(Stream&& from) noexcept
560 : Stream() {
561 *this = ::std::move(from);
562 }
563
564 inline Stream& operator=(const Stream& from) {
565 CopyFrom(from);
566 return *this;
567 }
568 inline Stream& operator=(Stream&& from) noexcept {
569 if (this == &from) return *this;
570 if (GetOwningArena() == from.GetOwningArena()
571 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
572 && GetOwningArena() != nullptr
573 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
574 ) {
575 InternalSwap(&from);
576 } else {
577 CopyFrom(from);
578 }
579 return *this;
580 }
581
unknown_fields()582 inline const std::string& unknown_fields() const {
583 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
584 }
mutable_unknown_fields()585 inline std::string* mutable_unknown_fields() {
586 return _internal_metadata_.mutable_unknown_fields<std::string>();
587 }
588
default_instance()589 static const Stream& default_instance() {
590 return *internal_default_instance();
591 }
internal_default_instance()592 static inline const Stream* internal_default_instance() {
593 return reinterpret_cast<const Stream*>(
594 &_Stream_default_instance_);
595 }
596 static constexpr int kIndexInFileMessages =
597 2;
598
swap(Stream & a,Stream & b)599 friend void swap(Stream& a, Stream& b) {
600 a.Swap(&b);
601 }
Swap(Stream * other)602 PROTOBUF_NOINLINE void Swap(Stream* other) {
603 if (other == this) return;
604 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
605 if (GetOwningArena() != nullptr &&
606 GetOwningArena() == other->GetOwningArena()) {
607 #else // PROTOBUF_FORCE_COPY_IN_SWAP
608 if (GetOwningArena() == other->GetOwningArena()) {
609 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
610 InternalSwap(other);
611 } else {
612 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
613 }
614 }
615 void UnsafeArenaSwap(Stream* other) {
616 if (other == this) return;
617 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
618 InternalSwap(other);
619 }
620
621 // implements Message ----------------------------------------------
622
623 Stream* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
624 return CreateMaybeMessage<Stream>(arena);
625 }
626 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
627 void CopyFrom(const Stream& from);
628 void MergeFrom(const Stream& from);
629 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
630 bool IsInitialized() const final;
631
632 size_t ByteSizeLong() const final;
633 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
634 uint8_t* _InternalSerialize(
635 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
636 int GetCachedSize() const final { return _cached_size_.Get(); }
637
638 private:
639 void SharedCtor();
640 void SharedDtor();
641 void SetCachedSize(int size) const;
642 void InternalSwap(Stream* other);
643
644 private:
645 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
646 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
647 return "webrtc.audioproc.Stream";
648 }
649 protected:
650 explicit Stream(::PROTOBUF_NAMESPACE_ID::Arena* arena,
651 bool is_message_owned = false);
652 public:
653
654 std::string GetTypeName() const final;
655
656 // nested types ----------------------------------------------------
657
658 // accessors -------------------------------------------------------
659
660 enum : int {
661 kInputChannelFieldNumber = 7,
662 kOutputChannelFieldNumber = 8,
663 kInputDataFieldNumber = 1,
664 kOutputDataFieldNumber = 2,
665 kDelayFieldNumber = 3,
666 kDriftFieldNumber = 4,
667 kAppliedInputVolumeFieldNumber = 5,
668 kKeypressFieldNumber = 6,
669 };
670 // repeated bytes input_channel = 7;
671 int input_channel_size() const;
672 private:
673 int _internal_input_channel_size() const;
674 public:
675 void clear_input_channel();
676 const std::string& input_channel(int index) const;
677 std::string* mutable_input_channel(int index);
678 void set_input_channel(int index, const std::string& value);
679 void set_input_channel(int index, std::string&& value);
680 void set_input_channel(int index, const char* value);
681 void set_input_channel(int index, const void* value, size_t size);
682 std::string* add_input_channel();
683 void add_input_channel(const std::string& value);
684 void add_input_channel(std::string&& value);
685 void add_input_channel(const char* value);
686 void add_input_channel(const void* value, size_t size);
687 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input_channel() const;
688 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input_channel();
689 private:
690 const std::string& _internal_input_channel(int index) const;
691 std::string* _internal_add_input_channel();
692 public:
693
694 // repeated bytes output_channel = 8;
695 int output_channel_size() const;
696 private:
697 int _internal_output_channel_size() const;
698 public:
699 void clear_output_channel();
700 const std::string& output_channel(int index) const;
701 std::string* mutable_output_channel(int index);
702 void set_output_channel(int index, const std::string& value);
703 void set_output_channel(int index, std::string&& value);
704 void set_output_channel(int index, const char* value);
705 void set_output_channel(int index, const void* value, size_t size);
706 std::string* add_output_channel();
707 void add_output_channel(const std::string& value);
708 void add_output_channel(std::string&& value);
709 void add_output_channel(const char* value);
710 void add_output_channel(const void* value, size_t size);
711 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& output_channel() const;
712 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_output_channel();
713 private:
714 const std::string& _internal_output_channel(int index) const;
715 std::string* _internal_add_output_channel();
716 public:
717
718 // optional bytes input_data = 1;
719 bool has_input_data() const;
720 private:
721 bool _internal_has_input_data() const;
722 public:
723 void clear_input_data();
724 const std::string& input_data() const;
725 template <typename ArgT0 = const std::string&, typename... ArgT>
726 void set_input_data(ArgT0&& arg0, ArgT... args);
727 std::string* mutable_input_data();
728 PROTOBUF_NODISCARD std::string* release_input_data();
729 void set_allocated_input_data(std::string* input_data);
730 private:
731 const std::string& _internal_input_data() const;
732 inline PROTOBUF_ALWAYS_INLINE void _internal_set_input_data(const std::string& value);
733 std::string* _internal_mutable_input_data();
734 public:
735
736 // optional bytes output_data = 2;
737 bool has_output_data() const;
738 private:
739 bool _internal_has_output_data() const;
740 public:
741 void clear_output_data();
742 const std::string& output_data() const;
743 template <typename ArgT0 = const std::string&, typename... ArgT>
744 void set_output_data(ArgT0&& arg0, ArgT... args);
745 std::string* mutable_output_data();
746 PROTOBUF_NODISCARD std::string* release_output_data();
747 void set_allocated_output_data(std::string* output_data);
748 private:
749 const std::string& _internal_output_data() const;
750 inline PROTOBUF_ALWAYS_INLINE void _internal_set_output_data(const std::string& value);
751 std::string* _internal_mutable_output_data();
752 public:
753
754 // optional int32 delay = 3;
755 bool has_delay() const;
756 private:
757 bool _internal_has_delay() const;
758 public:
759 void clear_delay();
760 int32_t delay() const;
761 void set_delay(int32_t value);
762 private:
763 int32_t _internal_delay() const;
764 void _internal_set_delay(int32_t value);
765 public:
766
767 // optional sint32 drift = 4;
768 bool has_drift() const;
769 private:
770 bool _internal_has_drift() const;
771 public:
772 void clear_drift();
773 int32_t drift() const;
774 void set_drift(int32_t value);
775 private:
776 int32_t _internal_drift() const;
777 void _internal_set_drift(int32_t value);
778 public:
779
780 // optional int32 applied_input_volume = 5;
781 bool has_applied_input_volume() const;
782 private:
783 bool _internal_has_applied_input_volume() const;
784 public:
785 void clear_applied_input_volume();
786 int32_t applied_input_volume() const;
787 void set_applied_input_volume(int32_t value);
788 private:
789 int32_t _internal_applied_input_volume() const;
790 void _internal_set_applied_input_volume(int32_t value);
791 public:
792
793 // optional bool keypress = 6;
794 bool has_keypress() const;
795 private:
796 bool _internal_has_keypress() const;
797 public:
798 void clear_keypress();
799 bool keypress() const;
800 void set_keypress(bool value);
801 private:
802 bool _internal_keypress() const;
803 void _internal_set_keypress(bool value);
804 public:
805
806 // @@protoc_insertion_point(class_scope:webrtc.audioproc.Stream)
807 private:
808 class _Internal;
809
810 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
811 typedef void InternalArenaConstructable_;
812 typedef void DestructorSkippable_;
813 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
814 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
815 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_channel_;
816 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> output_channel_;
817 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr input_data_;
818 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_data_;
819 int32_t delay_;
820 int32_t drift_;
821 int32_t applied_input_volume_;
822 bool keypress_;
823 friend struct ::TableStruct_debug_2eproto;
824 };
825 // -------------------------------------------------------------------
826
827 class Config final :
828 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Config) */ {
829 public:
Config()830 inline Config() : Config(nullptr) {}
831 ~Config() override;
832 explicit PROTOBUF_CONSTEXPR Config(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
833
834 Config(const Config& from);
Config(Config && from)835 Config(Config&& from) noexcept
836 : Config() {
837 *this = ::std::move(from);
838 }
839
840 inline Config& operator=(const Config& from) {
841 CopyFrom(from);
842 return *this;
843 }
844 inline Config& operator=(Config&& from) noexcept {
845 if (this == &from) return *this;
846 if (GetOwningArena() == from.GetOwningArena()
847 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
848 && GetOwningArena() != nullptr
849 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
850 ) {
851 InternalSwap(&from);
852 } else {
853 CopyFrom(from);
854 }
855 return *this;
856 }
857
unknown_fields()858 inline const std::string& unknown_fields() const {
859 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
860 }
mutable_unknown_fields()861 inline std::string* mutable_unknown_fields() {
862 return _internal_metadata_.mutable_unknown_fields<std::string>();
863 }
864
default_instance()865 static const Config& default_instance() {
866 return *internal_default_instance();
867 }
internal_default_instance()868 static inline const Config* internal_default_instance() {
869 return reinterpret_cast<const Config*>(
870 &_Config_default_instance_);
871 }
872 static constexpr int kIndexInFileMessages =
873 3;
874
swap(Config & a,Config & b)875 friend void swap(Config& a, Config& b) {
876 a.Swap(&b);
877 }
Swap(Config * other)878 PROTOBUF_NOINLINE void Swap(Config* other) {
879 if (other == this) return;
880 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
881 if (GetOwningArena() != nullptr &&
882 GetOwningArena() == other->GetOwningArena()) {
883 #else // PROTOBUF_FORCE_COPY_IN_SWAP
884 if (GetOwningArena() == other->GetOwningArena()) {
885 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
886 InternalSwap(other);
887 } else {
888 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
889 }
890 }
891 void UnsafeArenaSwap(Config* other) {
892 if (other == this) return;
893 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
894 InternalSwap(other);
895 }
896
897 // implements Message ----------------------------------------------
898
899 Config* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
900 return CreateMaybeMessage<Config>(arena);
901 }
902 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
903 void CopyFrom(const Config& from);
904 void MergeFrom(const Config& from);
905 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
906 bool IsInitialized() const final;
907
908 size_t ByteSizeLong() const final;
909 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
910 uint8_t* _InternalSerialize(
911 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
912 int GetCachedSize() const final { return _cached_size_.Get(); }
913
914 private:
915 void SharedCtor();
916 void SharedDtor();
917 void SetCachedSize(int size) const;
918 void InternalSwap(Config* other);
919
920 private:
921 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
922 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
923 return "webrtc.audioproc.Config";
924 }
925 protected:
926 explicit Config(::PROTOBUF_NAMESPACE_ID::Arena* arena,
927 bool is_message_owned = false);
928 public:
929
930 std::string GetTypeName() const final;
931
932 // nested types ----------------------------------------------------
933
934 // accessors -------------------------------------------------------
935
936 enum : int {
937 kExperimentsDescriptionFieldNumber = 17,
938 kAecEnabledFieldNumber = 1,
939 kAecDelayAgnosticEnabledFieldNumber = 2,
940 kAecDriftCompensationEnabledFieldNumber = 3,
941 kAecExtendedFilterEnabledFieldNumber = 4,
942 kAecSuppressionLevelFieldNumber = 5,
943 kAecmRoutingModeFieldNumber = 8,
944 kAecmEnabledFieldNumber = 6,
945 kAecmComfortNoiseEnabledFieldNumber = 7,
946 kAgcEnabledFieldNumber = 9,
947 kAgcLimiterEnabledFieldNumber = 11,
948 kAgcModeFieldNumber = 10,
949 kNoiseRobustAgcEnabledFieldNumber = 12,
950 kHpfEnabledFieldNumber = 13,
951 kNsEnabledFieldNumber = 14,
952 kTransientSuppressionEnabledFieldNumber = 16,
953 kNsLevelFieldNumber = 15,
954 kPreAmplifierEnabledFieldNumber = 19,
955 kPreAmplifierFixedGainFactorFieldNumber = 20,
956 };
957 // optional string experiments_description = 17;
958 bool has_experiments_description() const;
959 private:
960 bool _internal_has_experiments_description() const;
961 public:
962 void clear_experiments_description();
963 const std::string& experiments_description() const;
964 template <typename ArgT0 = const std::string&, typename... ArgT>
965 void set_experiments_description(ArgT0&& arg0, ArgT... args);
966 std::string* mutable_experiments_description();
967 PROTOBUF_NODISCARD std::string* release_experiments_description();
968 void set_allocated_experiments_description(std::string* experiments_description);
969 private:
970 const std::string& _internal_experiments_description() const;
971 inline PROTOBUF_ALWAYS_INLINE void _internal_set_experiments_description(const std::string& value);
972 std::string* _internal_mutable_experiments_description();
973 public:
974
975 // optional bool aec_enabled = 1;
976 bool has_aec_enabled() const;
977 private:
978 bool _internal_has_aec_enabled() const;
979 public:
980 void clear_aec_enabled();
981 bool aec_enabled() const;
982 void set_aec_enabled(bool value);
983 private:
984 bool _internal_aec_enabled() const;
985 void _internal_set_aec_enabled(bool value);
986 public:
987
988 // optional bool aec_delay_agnostic_enabled = 2;
989 bool has_aec_delay_agnostic_enabled() const;
990 private:
991 bool _internal_has_aec_delay_agnostic_enabled() const;
992 public:
993 void clear_aec_delay_agnostic_enabled();
994 bool aec_delay_agnostic_enabled() const;
995 void set_aec_delay_agnostic_enabled(bool value);
996 private:
997 bool _internal_aec_delay_agnostic_enabled() const;
998 void _internal_set_aec_delay_agnostic_enabled(bool value);
999 public:
1000
1001 // optional bool aec_drift_compensation_enabled = 3;
1002 bool has_aec_drift_compensation_enabled() const;
1003 private:
1004 bool _internal_has_aec_drift_compensation_enabled() const;
1005 public:
1006 void clear_aec_drift_compensation_enabled();
1007 bool aec_drift_compensation_enabled() const;
1008 void set_aec_drift_compensation_enabled(bool value);
1009 private:
1010 bool _internal_aec_drift_compensation_enabled() const;
1011 void _internal_set_aec_drift_compensation_enabled(bool value);
1012 public:
1013
1014 // optional bool aec_extended_filter_enabled = 4;
1015 bool has_aec_extended_filter_enabled() const;
1016 private:
1017 bool _internal_has_aec_extended_filter_enabled() const;
1018 public:
1019 void clear_aec_extended_filter_enabled();
1020 bool aec_extended_filter_enabled() const;
1021 void set_aec_extended_filter_enabled(bool value);
1022 private:
1023 bool _internal_aec_extended_filter_enabled() const;
1024 void _internal_set_aec_extended_filter_enabled(bool value);
1025 public:
1026
1027 // optional int32 aec_suppression_level = 5;
1028 bool has_aec_suppression_level() const;
1029 private:
1030 bool _internal_has_aec_suppression_level() const;
1031 public:
1032 void clear_aec_suppression_level();
1033 int32_t aec_suppression_level() const;
1034 void set_aec_suppression_level(int32_t value);
1035 private:
1036 int32_t _internal_aec_suppression_level() const;
1037 void _internal_set_aec_suppression_level(int32_t value);
1038 public:
1039
1040 // optional int32 aecm_routing_mode = 8 [deprecated = true];
1041 PROTOBUF_DEPRECATED bool has_aecm_routing_mode() const;
1042 private:
1043 bool _internal_has_aecm_routing_mode() const;
1044 public:
1045 PROTOBUF_DEPRECATED void clear_aecm_routing_mode();
1046 PROTOBUF_DEPRECATED int32_t aecm_routing_mode() const;
1047 PROTOBUF_DEPRECATED void set_aecm_routing_mode(int32_t value);
1048 private:
1049 int32_t _internal_aecm_routing_mode() const;
1050 void _internal_set_aecm_routing_mode(int32_t value);
1051 public:
1052
1053 // optional bool aecm_enabled = 6;
1054 bool has_aecm_enabled() const;
1055 private:
1056 bool _internal_has_aecm_enabled() const;
1057 public:
1058 void clear_aecm_enabled();
1059 bool aecm_enabled() const;
1060 void set_aecm_enabled(bool value);
1061 private:
1062 bool _internal_aecm_enabled() const;
1063 void _internal_set_aecm_enabled(bool value);
1064 public:
1065
1066 // optional bool aecm_comfort_noise_enabled = 7 [deprecated = true];
1067 PROTOBUF_DEPRECATED bool has_aecm_comfort_noise_enabled() const;
1068 private:
1069 bool _internal_has_aecm_comfort_noise_enabled() const;
1070 public:
1071 PROTOBUF_DEPRECATED void clear_aecm_comfort_noise_enabled();
1072 PROTOBUF_DEPRECATED bool aecm_comfort_noise_enabled() const;
1073 PROTOBUF_DEPRECATED void set_aecm_comfort_noise_enabled(bool value);
1074 private:
1075 bool _internal_aecm_comfort_noise_enabled() const;
1076 void _internal_set_aecm_comfort_noise_enabled(bool value);
1077 public:
1078
1079 // optional bool agc_enabled = 9;
1080 bool has_agc_enabled() const;
1081 private:
1082 bool _internal_has_agc_enabled() const;
1083 public:
1084 void clear_agc_enabled();
1085 bool agc_enabled() const;
1086 void set_agc_enabled(bool value);
1087 private:
1088 bool _internal_agc_enabled() const;
1089 void _internal_set_agc_enabled(bool value);
1090 public:
1091
1092 // optional bool agc_limiter_enabled = 11;
1093 bool has_agc_limiter_enabled() const;
1094 private:
1095 bool _internal_has_agc_limiter_enabled() const;
1096 public:
1097 void clear_agc_limiter_enabled();
1098 bool agc_limiter_enabled() const;
1099 void set_agc_limiter_enabled(bool value);
1100 private:
1101 bool _internal_agc_limiter_enabled() const;
1102 void _internal_set_agc_limiter_enabled(bool value);
1103 public:
1104
1105 // optional int32 agc_mode = 10;
1106 bool has_agc_mode() const;
1107 private:
1108 bool _internal_has_agc_mode() const;
1109 public:
1110 void clear_agc_mode();
1111 int32_t agc_mode() const;
1112 void set_agc_mode(int32_t value);
1113 private:
1114 int32_t _internal_agc_mode() const;
1115 void _internal_set_agc_mode(int32_t value);
1116 public:
1117
1118 // optional bool noise_robust_agc_enabled = 12;
1119 bool has_noise_robust_agc_enabled() const;
1120 private:
1121 bool _internal_has_noise_robust_agc_enabled() const;
1122 public:
1123 void clear_noise_robust_agc_enabled();
1124 bool noise_robust_agc_enabled() const;
1125 void set_noise_robust_agc_enabled(bool value);
1126 private:
1127 bool _internal_noise_robust_agc_enabled() const;
1128 void _internal_set_noise_robust_agc_enabled(bool value);
1129 public:
1130
1131 // optional bool hpf_enabled = 13;
1132 bool has_hpf_enabled() const;
1133 private:
1134 bool _internal_has_hpf_enabled() const;
1135 public:
1136 void clear_hpf_enabled();
1137 bool hpf_enabled() const;
1138 void set_hpf_enabled(bool value);
1139 private:
1140 bool _internal_hpf_enabled() const;
1141 void _internal_set_hpf_enabled(bool value);
1142 public:
1143
1144 // optional bool ns_enabled = 14;
1145 bool has_ns_enabled() const;
1146 private:
1147 bool _internal_has_ns_enabled() const;
1148 public:
1149 void clear_ns_enabled();
1150 bool ns_enabled() const;
1151 void set_ns_enabled(bool value);
1152 private:
1153 bool _internal_ns_enabled() const;
1154 void _internal_set_ns_enabled(bool value);
1155 public:
1156
1157 // optional bool transient_suppression_enabled = 16;
1158 bool has_transient_suppression_enabled() const;
1159 private:
1160 bool _internal_has_transient_suppression_enabled() const;
1161 public:
1162 void clear_transient_suppression_enabled();
1163 bool transient_suppression_enabled() const;
1164 void set_transient_suppression_enabled(bool value);
1165 private:
1166 bool _internal_transient_suppression_enabled() const;
1167 void _internal_set_transient_suppression_enabled(bool value);
1168 public:
1169
1170 // optional int32 ns_level = 15;
1171 bool has_ns_level() const;
1172 private:
1173 bool _internal_has_ns_level() const;
1174 public:
1175 void clear_ns_level();
1176 int32_t ns_level() const;
1177 void set_ns_level(int32_t value);
1178 private:
1179 int32_t _internal_ns_level() const;
1180 void _internal_set_ns_level(int32_t value);
1181 public:
1182
1183 // optional bool pre_amplifier_enabled = 19;
1184 bool has_pre_amplifier_enabled() const;
1185 private:
1186 bool _internal_has_pre_amplifier_enabled() const;
1187 public:
1188 void clear_pre_amplifier_enabled();
1189 bool pre_amplifier_enabled() const;
1190 void set_pre_amplifier_enabled(bool value);
1191 private:
1192 bool _internal_pre_amplifier_enabled() const;
1193 void _internal_set_pre_amplifier_enabled(bool value);
1194 public:
1195
1196 // optional float pre_amplifier_fixed_gain_factor = 20;
1197 bool has_pre_amplifier_fixed_gain_factor() const;
1198 private:
1199 bool _internal_has_pre_amplifier_fixed_gain_factor() const;
1200 public:
1201 void clear_pre_amplifier_fixed_gain_factor();
1202 float pre_amplifier_fixed_gain_factor() const;
1203 void set_pre_amplifier_fixed_gain_factor(float value);
1204 private:
1205 float _internal_pre_amplifier_fixed_gain_factor() const;
1206 void _internal_set_pre_amplifier_fixed_gain_factor(float value);
1207 public:
1208
1209 // @@protoc_insertion_point(class_scope:webrtc.audioproc.Config)
1210 private:
1211 class _Internal;
1212
1213 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1214 typedef void InternalArenaConstructable_;
1215 typedef void DestructorSkippable_;
1216 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1217 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1218 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr experiments_description_;
1219 bool aec_enabled_;
1220 bool aec_delay_agnostic_enabled_;
1221 bool aec_drift_compensation_enabled_;
1222 bool aec_extended_filter_enabled_;
1223 int32_t aec_suppression_level_;
1224 int32_t aecm_routing_mode_;
1225 bool aecm_enabled_;
1226 bool aecm_comfort_noise_enabled_;
1227 bool agc_enabled_;
1228 bool agc_limiter_enabled_;
1229 int32_t agc_mode_;
1230 bool noise_robust_agc_enabled_;
1231 bool hpf_enabled_;
1232 bool ns_enabled_;
1233 bool transient_suppression_enabled_;
1234 int32_t ns_level_;
1235 bool pre_amplifier_enabled_;
1236 float pre_amplifier_fixed_gain_factor_;
1237 friend struct ::TableStruct_debug_2eproto;
1238 };
1239 // -------------------------------------------------------------------
1240
1241 class PlayoutAudioDeviceInfo final :
1242 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.PlayoutAudioDeviceInfo) */ {
1243 public:
PlayoutAudioDeviceInfo()1244 inline PlayoutAudioDeviceInfo() : PlayoutAudioDeviceInfo(nullptr) {}
1245 ~PlayoutAudioDeviceInfo() override;
1246 explicit PROTOBUF_CONSTEXPR PlayoutAudioDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1247
1248 PlayoutAudioDeviceInfo(const PlayoutAudioDeviceInfo& from);
PlayoutAudioDeviceInfo(PlayoutAudioDeviceInfo && from)1249 PlayoutAudioDeviceInfo(PlayoutAudioDeviceInfo&& from) noexcept
1250 : PlayoutAudioDeviceInfo() {
1251 *this = ::std::move(from);
1252 }
1253
1254 inline PlayoutAudioDeviceInfo& operator=(const PlayoutAudioDeviceInfo& from) {
1255 CopyFrom(from);
1256 return *this;
1257 }
1258 inline PlayoutAudioDeviceInfo& operator=(PlayoutAudioDeviceInfo&& from) noexcept {
1259 if (this == &from) return *this;
1260 if (GetOwningArena() == from.GetOwningArena()
1261 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1262 && GetOwningArena() != nullptr
1263 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1264 ) {
1265 InternalSwap(&from);
1266 } else {
1267 CopyFrom(from);
1268 }
1269 return *this;
1270 }
1271
unknown_fields()1272 inline const std::string& unknown_fields() const {
1273 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1274 }
mutable_unknown_fields()1275 inline std::string* mutable_unknown_fields() {
1276 return _internal_metadata_.mutable_unknown_fields<std::string>();
1277 }
1278
default_instance()1279 static const PlayoutAudioDeviceInfo& default_instance() {
1280 return *internal_default_instance();
1281 }
internal_default_instance()1282 static inline const PlayoutAudioDeviceInfo* internal_default_instance() {
1283 return reinterpret_cast<const PlayoutAudioDeviceInfo*>(
1284 &_PlayoutAudioDeviceInfo_default_instance_);
1285 }
1286 static constexpr int kIndexInFileMessages =
1287 4;
1288
swap(PlayoutAudioDeviceInfo & a,PlayoutAudioDeviceInfo & b)1289 friend void swap(PlayoutAudioDeviceInfo& a, PlayoutAudioDeviceInfo& b) {
1290 a.Swap(&b);
1291 }
Swap(PlayoutAudioDeviceInfo * other)1292 PROTOBUF_NOINLINE void Swap(PlayoutAudioDeviceInfo* other) {
1293 if (other == this) return;
1294 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1295 if (GetOwningArena() != nullptr &&
1296 GetOwningArena() == other->GetOwningArena()) {
1297 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1298 if (GetOwningArena() == other->GetOwningArena()) {
1299 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1300 InternalSwap(other);
1301 } else {
1302 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1303 }
1304 }
1305 void UnsafeArenaSwap(PlayoutAudioDeviceInfo* other) {
1306 if (other == this) return;
1307 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1308 InternalSwap(other);
1309 }
1310
1311 // implements Message ----------------------------------------------
1312
1313 PlayoutAudioDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1314 return CreateMaybeMessage<PlayoutAudioDeviceInfo>(arena);
1315 }
1316 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1317 void CopyFrom(const PlayoutAudioDeviceInfo& from);
1318 void MergeFrom(const PlayoutAudioDeviceInfo& from);
1319 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1320 bool IsInitialized() const final;
1321
1322 size_t ByteSizeLong() const final;
1323 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1324 uint8_t* _InternalSerialize(
1325 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1326 int GetCachedSize() const final { return _cached_size_.Get(); }
1327
1328 private:
1329 void SharedCtor();
1330 void SharedDtor();
1331 void SetCachedSize(int size) const;
1332 void InternalSwap(PlayoutAudioDeviceInfo* other);
1333
1334 private:
1335 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1336 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1337 return "webrtc.audioproc.PlayoutAudioDeviceInfo";
1338 }
1339 protected:
1340 explicit PlayoutAudioDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1341 bool is_message_owned = false);
1342 public:
1343
1344 std::string GetTypeName() const final;
1345
1346 // nested types ----------------------------------------------------
1347
1348 // accessors -------------------------------------------------------
1349
1350 enum : int {
1351 kIdFieldNumber = 1,
1352 kMaxVolumeFieldNumber = 2,
1353 };
1354 // optional int32 id = 1;
1355 bool has_id() const;
1356 private:
1357 bool _internal_has_id() const;
1358 public:
1359 void clear_id();
1360 int32_t id() const;
1361 void set_id(int32_t value);
1362 private:
1363 int32_t _internal_id() const;
1364 void _internal_set_id(int32_t value);
1365 public:
1366
1367 // optional int32 max_volume = 2;
1368 bool has_max_volume() const;
1369 private:
1370 bool _internal_has_max_volume() const;
1371 public:
1372 void clear_max_volume();
1373 int32_t max_volume() const;
1374 void set_max_volume(int32_t value);
1375 private:
1376 int32_t _internal_max_volume() const;
1377 void _internal_set_max_volume(int32_t value);
1378 public:
1379
1380 // @@protoc_insertion_point(class_scope:webrtc.audioproc.PlayoutAudioDeviceInfo)
1381 private:
1382 class _Internal;
1383
1384 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1385 typedef void InternalArenaConstructable_;
1386 typedef void DestructorSkippable_;
1387 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1388 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1389 int32_t id_;
1390 int32_t max_volume_;
1391 friend struct ::TableStruct_debug_2eproto;
1392 };
1393 // -------------------------------------------------------------------
1394
1395 class RuntimeSetting final :
1396 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.RuntimeSetting) */ {
1397 public:
RuntimeSetting()1398 inline RuntimeSetting() : RuntimeSetting(nullptr) {}
1399 ~RuntimeSetting() override;
1400 explicit PROTOBUF_CONSTEXPR RuntimeSetting(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1401
1402 RuntimeSetting(const RuntimeSetting& from);
RuntimeSetting(RuntimeSetting && from)1403 RuntimeSetting(RuntimeSetting&& from) noexcept
1404 : RuntimeSetting() {
1405 *this = ::std::move(from);
1406 }
1407
1408 inline RuntimeSetting& operator=(const RuntimeSetting& from) {
1409 CopyFrom(from);
1410 return *this;
1411 }
1412 inline RuntimeSetting& operator=(RuntimeSetting&& from) noexcept {
1413 if (this == &from) return *this;
1414 if (GetOwningArena() == from.GetOwningArena()
1415 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1416 && GetOwningArena() != nullptr
1417 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1418 ) {
1419 InternalSwap(&from);
1420 } else {
1421 CopyFrom(from);
1422 }
1423 return *this;
1424 }
1425
unknown_fields()1426 inline const std::string& unknown_fields() const {
1427 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1428 }
mutable_unknown_fields()1429 inline std::string* mutable_unknown_fields() {
1430 return _internal_metadata_.mutable_unknown_fields<std::string>();
1431 }
1432
default_instance()1433 static const RuntimeSetting& default_instance() {
1434 return *internal_default_instance();
1435 }
internal_default_instance()1436 static inline const RuntimeSetting* internal_default_instance() {
1437 return reinterpret_cast<const RuntimeSetting*>(
1438 &_RuntimeSetting_default_instance_);
1439 }
1440 static constexpr int kIndexInFileMessages =
1441 5;
1442
swap(RuntimeSetting & a,RuntimeSetting & b)1443 friend void swap(RuntimeSetting& a, RuntimeSetting& b) {
1444 a.Swap(&b);
1445 }
Swap(RuntimeSetting * other)1446 PROTOBUF_NOINLINE void Swap(RuntimeSetting* other) {
1447 if (other == this) return;
1448 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1449 if (GetOwningArena() != nullptr &&
1450 GetOwningArena() == other->GetOwningArena()) {
1451 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1452 if (GetOwningArena() == other->GetOwningArena()) {
1453 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1454 InternalSwap(other);
1455 } else {
1456 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1457 }
1458 }
1459 void UnsafeArenaSwap(RuntimeSetting* other) {
1460 if (other == this) return;
1461 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1462 InternalSwap(other);
1463 }
1464
1465 // implements Message ----------------------------------------------
1466
1467 RuntimeSetting* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1468 return CreateMaybeMessage<RuntimeSetting>(arena);
1469 }
1470 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1471 void CopyFrom(const RuntimeSetting& from);
1472 void MergeFrom(const RuntimeSetting& from);
1473 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1474 bool IsInitialized() const final;
1475
1476 size_t ByteSizeLong() const final;
1477 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1478 uint8_t* _InternalSerialize(
1479 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1480 int GetCachedSize() const final { return _cached_size_.Get(); }
1481
1482 private:
1483 void SharedCtor();
1484 void SharedDtor();
1485 void SetCachedSize(int size) const;
1486 void InternalSwap(RuntimeSetting* other);
1487
1488 private:
1489 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1490 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1491 return "webrtc.audioproc.RuntimeSetting";
1492 }
1493 protected:
1494 explicit RuntimeSetting(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1495 bool is_message_owned = false);
1496 public:
1497
1498 std::string GetTypeName() const final;
1499
1500 // nested types ----------------------------------------------------
1501
1502 // accessors -------------------------------------------------------
1503
1504 enum : int {
1505 kPlayoutAudioDeviceChangeFieldNumber = 5,
1506 kCapturePreGainFieldNumber = 1,
1507 kCustomRenderProcessingSettingFieldNumber = 2,
1508 kCaptureFixedPostGainFieldNumber = 3,
1509 kPlayoutVolumeChangeFieldNumber = 4,
1510 kCaptureOutputUsedFieldNumber = 6,
1511 kCapturePostGainFieldNumber = 7,
1512 };
1513 // optional .webrtc.audioproc.PlayoutAudioDeviceInfo playout_audio_device_change = 5;
1514 bool has_playout_audio_device_change() const;
1515 private:
1516 bool _internal_has_playout_audio_device_change() const;
1517 public:
1518 void clear_playout_audio_device_change();
1519 const ::webrtc::audioproc::PlayoutAudioDeviceInfo& playout_audio_device_change() const;
1520 PROTOBUF_NODISCARD ::webrtc::audioproc::PlayoutAudioDeviceInfo* release_playout_audio_device_change();
1521 ::webrtc::audioproc::PlayoutAudioDeviceInfo* mutable_playout_audio_device_change();
1522 void set_allocated_playout_audio_device_change(::webrtc::audioproc::PlayoutAudioDeviceInfo* playout_audio_device_change);
1523 private:
1524 const ::webrtc::audioproc::PlayoutAudioDeviceInfo& _internal_playout_audio_device_change() const;
1525 ::webrtc::audioproc::PlayoutAudioDeviceInfo* _internal_mutable_playout_audio_device_change();
1526 public:
1527 void unsafe_arena_set_allocated_playout_audio_device_change(
1528 ::webrtc::audioproc::PlayoutAudioDeviceInfo* playout_audio_device_change);
1529 ::webrtc::audioproc::PlayoutAudioDeviceInfo* unsafe_arena_release_playout_audio_device_change();
1530
1531 // optional float capture_pre_gain = 1;
1532 bool has_capture_pre_gain() const;
1533 private:
1534 bool _internal_has_capture_pre_gain() const;
1535 public:
1536 void clear_capture_pre_gain();
1537 float capture_pre_gain() const;
1538 void set_capture_pre_gain(float value);
1539 private:
1540 float _internal_capture_pre_gain() const;
1541 void _internal_set_capture_pre_gain(float value);
1542 public:
1543
1544 // optional float custom_render_processing_setting = 2;
1545 bool has_custom_render_processing_setting() const;
1546 private:
1547 bool _internal_has_custom_render_processing_setting() const;
1548 public:
1549 void clear_custom_render_processing_setting();
1550 float custom_render_processing_setting() const;
1551 void set_custom_render_processing_setting(float value);
1552 private:
1553 float _internal_custom_render_processing_setting() const;
1554 void _internal_set_custom_render_processing_setting(float value);
1555 public:
1556
1557 // optional float capture_fixed_post_gain = 3;
1558 bool has_capture_fixed_post_gain() const;
1559 private:
1560 bool _internal_has_capture_fixed_post_gain() const;
1561 public:
1562 void clear_capture_fixed_post_gain();
1563 float capture_fixed_post_gain() const;
1564 void set_capture_fixed_post_gain(float value);
1565 private:
1566 float _internal_capture_fixed_post_gain() const;
1567 void _internal_set_capture_fixed_post_gain(float value);
1568 public:
1569
1570 // optional int32 playout_volume_change = 4;
1571 bool has_playout_volume_change() const;
1572 private:
1573 bool _internal_has_playout_volume_change() const;
1574 public:
1575 void clear_playout_volume_change();
1576 int32_t playout_volume_change() const;
1577 void set_playout_volume_change(int32_t value);
1578 private:
1579 int32_t _internal_playout_volume_change() const;
1580 void _internal_set_playout_volume_change(int32_t value);
1581 public:
1582
1583 // optional bool capture_output_used = 6;
1584 bool has_capture_output_used() const;
1585 private:
1586 bool _internal_has_capture_output_used() const;
1587 public:
1588 void clear_capture_output_used();
1589 bool capture_output_used() const;
1590 void set_capture_output_used(bool value);
1591 private:
1592 bool _internal_capture_output_used() const;
1593 void _internal_set_capture_output_used(bool value);
1594 public:
1595
1596 // optional float capture_post_gain = 7;
1597 bool has_capture_post_gain() const;
1598 private:
1599 bool _internal_has_capture_post_gain() const;
1600 public:
1601 void clear_capture_post_gain();
1602 float capture_post_gain() const;
1603 void set_capture_post_gain(float value);
1604 private:
1605 float _internal_capture_post_gain() const;
1606 void _internal_set_capture_post_gain(float value);
1607 public:
1608
1609 // @@protoc_insertion_point(class_scope:webrtc.audioproc.RuntimeSetting)
1610 private:
1611 class _Internal;
1612
1613 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1614 typedef void InternalArenaConstructable_;
1615 typedef void DestructorSkippable_;
1616 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1617 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1618 ::webrtc::audioproc::PlayoutAudioDeviceInfo* playout_audio_device_change_;
1619 float capture_pre_gain_;
1620 float custom_render_processing_setting_;
1621 float capture_fixed_post_gain_;
1622 int32_t playout_volume_change_;
1623 bool capture_output_used_;
1624 float capture_post_gain_;
1625 friend struct ::TableStruct_debug_2eproto;
1626 };
1627 // -------------------------------------------------------------------
1628
1629 class Event final :
1630 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Event) */ {
1631 public:
Event()1632 inline Event() : Event(nullptr) {}
1633 ~Event() override;
1634 explicit PROTOBUF_CONSTEXPR Event(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1635
1636 Event(const Event& from);
Event(Event && from)1637 Event(Event&& from) noexcept
1638 : Event() {
1639 *this = ::std::move(from);
1640 }
1641
1642 inline Event& operator=(const Event& from) {
1643 CopyFrom(from);
1644 return *this;
1645 }
1646 inline Event& operator=(Event&& from) noexcept {
1647 if (this == &from) return *this;
1648 if (GetOwningArena() == from.GetOwningArena()
1649 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1650 && GetOwningArena() != nullptr
1651 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1652 ) {
1653 InternalSwap(&from);
1654 } else {
1655 CopyFrom(from);
1656 }
1657 return *this;
1658 }
1659
unknown_fields()1660 inline const std::string& unknown_fields() const {
1661 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1662 }
mutable_unknown_fields()1663 inline std::string* mutable_unknown_fields() {
1664 return _internal_metadata_.mutable_unknown_fields<std::string>();
1665 }
1666
default_instance()1667 static const Event& default_instance() {
1668 return *internal_default_instance();
1669 }
internal_default_instance()1670 static inline const Event* internal_default_instance() {
1671 return reinterpret_cast<const Event*>(
1672 &_Event_default_instance_);
1673 }
1674 static constexpr int kIndexInFileMessages =
1675 6;
1676
swap(Event & a,Event & b)1677 friend void swap(Event& a, Event& b) {
1678 a.Swap(&b);
1679 }
Swap(Event * other)1680 PROTOBUF_NOINLINE void Swap(Event* other) {
1681 if (other == this) return;
1682 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1683 if (GetOwningArena() != nullptr &&
1684 GetOwningArena() == other->GetOwningArena()) {
1685 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1686 if (GetOwningArena() == other->GetOwningArena()) {
1687 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1688 InternalSwap(other);
1689 } else {
1690 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1691 }
1692 }
1693 void UnsafeArenaSwap(Event* other) {
1694 if (other == this) return;
1695 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1696 InternalSwap(other);
1697 }
1698
1699 // implements Message ----------------------------------------------
1700
1701 Event* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1702 return CreateMaybeMessage<Event>(arena);
1703 }
1704 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1705 void CopyFrom(const Event& from);
1706 void MergeFrom(const Event& from);
1707 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1708 bool IsInitialized() const final;
1709
1710 size_t ByteSizeLong() const final;
1711 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1712 uint8_t* _InternalSerialize(
1713 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1714 int GetCachedSize() const final { return _cached_size_.Get(); }
1715
1716 private:
1717 void SharedCtor();
1718 void SharedDtor();
1719 void SetCachedSize(int size) const;
1720 void InternalSwap(Event* other);
1721
1722 private:
1723 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1724 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1725 return "webrtc.audioproc.Event";
1726 }
1727 protected:
1728 explicit Event(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1729 bool is_message_owned = false);
1730 public:
1731
1732 std::string GetTypeName() const final;
1733
1734 // nested types ----------------------------------------------------
1735
1736 typedef Event_Type Type;
1737 static constexpr Type INIT =
1738 Event_Type_INIT;
1739 static constexpr Type REVERSE_STREAM =
1740 Event_Type_REVERSE_STREAM;
1741 static constexpr Type STREAM =
1742 Event_Type_STREAM;
1743 static constexpr Type CONFIG =
1744 Event_Type_CONFIG;
1745 static constexpr Type UNKNOWN_EVENT =
1746 Event_Type_UNKNOWN_EVENT;
1747 static constexpr Type RUNTIME_SETTING =
1748 Event_Type_RUNTIME_SETTING;
1749 static inline bool Type_IsValid(int value) {
1750 return Event_Type_IsValid(value);
1751 }
1752 static constexpr Type Type_MIN =
1753 Event_Type_Type_MIN;
1754 static constexpr Type Type_MAX =
1755 Event_Type_Type_MAX;
1756 static constexpr int Type_ARRAYSIZE =
1757 Event_Type_Type_ARRAYSIZE;
1758 template<typename T>
1759 static inline const std::string& Type_Name(T enum_t_value) {
1760 static_assert(::std::is_same<T, Type>::value ||
1761 ::std::is_integral<T>::value,
1762 "Incorrect type passed to function Type_Name.");
1763 return Event_Type_Name(enum_t_value);
1764 }
1765 static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1766 Type* value) {
1767 return Event_Type_Parse(name, value);
1768 }
1769
1770 // accessors -------------------------------------------------------
1771
1772 enum : int {
1773 kInitFieldNumber = 2,
1774 kReverseStreamFieldNumber = 3,
1775 kStreamFieldNumber = 4,
1776 kConfigFieldNumber = 5,
1777 kRuntimeSettingFieldNumber = 6,
1778 kTypeFieldNumber = 1,
1779 };
1780 // optional .webrtc.audioproc.Init init = 2;
1781 bool has_init() const;
1782 private:
1783 bool _internal_has_init() const;
1784 public:
1785 void clear_init();
1786 const ::webrtc::audioproc::Init& init() const;
1787 PROTOBUF_NODISCARD ::webrtc::audioproc::Init* release_init();
1788 ::webrtc::audioproc::Init* mutable_init();
1789 void set_allocated_init(::webrtc::audioproc::Init* init);
1790 private:
1791 const ::webrtc::audioproc::Init& _internal_init() const;
1792 ::webrtc::audioproc::Init* _internal_mutable_init();
1793 public:
1794 void unsafe_arena_set_allocated_init(
1795 ::webrtc::audioproc::Init* init);
1796 ::webrtc::audioproc::Init* unsafe_arena_release_init();
1797
1798 // optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
1799 bool has_reverse_stream() const;
1800 private:
1801 bool _internal_has_reverse_stream() const;
1802 public:
1803 void clear_reverse_stream();
1804 const ::webrtc::audioproc::ReverseStream& reverse_stream() const;
1805 PROTOBUF_NODISCARD ::webrtc::audioproc::ReverseStream* release_reverse_stream();
1806 ::webrtc::audioproc::ReverseStream* mutable_reverse_stream();
1807 void set_allocated_reverse_stream(::webrtc::audioproc::ReverseStream* reverse_stream);
1808 private:
1809 const ::webrtc::audioproc::ReverseStream& _internal_reverse_stream() const;
1810 ::webrtc::audioproc::ReverseStream* _internal_mutable_reverse_stream();
1811 public:
1812 void unsafe_arena_set_allocated_reverse_stream(
1813 ::webrtc::audioproc::ReverseStream* reverse_stream);
1814 ::webrtc::audioproc::ReverseStream* unsafe_arena_release_reverse_stream();
1815
1816 // optional .webrtc.audioproc.Stream stream = 4;
1817 bool has_stream() const;
1818 private:
1819 bool _internal_has_stream() const;
1820 public:
1821 void clear_stream();
1822 const ::webrtc::audioproc::Stream& stream() const;
1823 PROTOBUF_NODISCARD ::webrtc::audioproc::Stream* release_stream();
1824 ::webrtc::audioproc::Stream* mutable_stream();
1825 void set_allocated_stream(::webrtc::audioproc::Stream* stream);
1826 private:
1827 const ::webrtc::audioproc::Stream& _internal_stream() const;
1828 ::webrtc::audioproc::Stream* _internal_mutable_stream();
1829 public:
1830 void unsafe_arena_set_allocated_stream(
1831 ::webrtc::audioproc::Stream* stream);
1832 ::webrtc::audioproc::Stream* unsafe_arena_release_stream();
1833
1834 // optional .webrtc.audioproc.Config config = 5;
1835 bool has_config() const;
1836 private:
1837 bool _internal_has_config() const;
1838 public:
1839 void clear_config();
1840 const ::webrtc::audioproc::Config& config() const;
1841 PROTOBUF_NODISCARD ::webrtc::audioproc::Config* release_config();
1842 ::webrtc::audioproc::Config* mutable_config();
1843 void set_allocated_config(::webrtc::audioproc::Config* config);
1844 private:
1845 const ::webrtc::audioproc::Config& _internal_config() const;
1846 ::webrtc::audioproc::Config* _internal_mutable_config();
1847 public:
1848 void unsafe_arena_set_allocated_config(
1849 ::webrtc::audioproc::Config* config);
1850 ::webrtc::audioproc::Config* unsafe_arena_release_config();
1851
1852 // optional .webrtc.audioproc.RuntimeSetting runtime_setting = 6;
1853 bool has_runtime_setting() const;
1854 private:
1855 bool _internal_has_runtime_setting() const;
1856 public:
1857 void clear_runtime_setting();
1858 const ::webrtc::audioproc::RuntimeSetting& runtime_setting() const;
1859 PROTOBUF_NODISCARD ::webrtc::audioproc::RuntimeSetting* release_runtime_setting();
1860 ::webrtc::audioproc::RuntimeSetting* mutable_runtime_setting();
1861 void set_allocated_runtime_setting(::webrtc::audioproc::RuntimeSetting* runtime_setting);
1862 private:
1863 const ::webrtc::audioproc::RuntimeSetting& _internal_runtime_setting() const;
1864 ::webrtc::audioproc::RuntimeSetting* _internal_mutable_runtime_setting();
1865 public:
1866 void unsafe_arena_set_allocated_runtime_setting(
1867 ::webrtc::audioproc::RuntimeSetting* runtime_setting);
1868 ::webrtc::audioproc::RuntimeSetting* unsafe_arena_release_runtime_setting();
1869
1870 // required .webrtc.audioproc.Event.Type type = 1;
1871 bool has_type() const;
1872 private:
1873 bool _internal_has_type() const;
1874 public:
1875 void clear_type();
1876 ::webrtc::audioproc::Event_Type type() const;
1877 void set_type(::webrtc::audioproc::Event_Type value);
1878 private:
1879 ::webrtc::audioproc::Event_Type _internal_type() const;
1880 void _internal_set_type(::webrtc::audioproc::Event_Type value);
1881 public:
1882
1883 // @@protoc_insertion_point(class_scope:webrtc.audioproc.Event)
1884 private:
1885 class _Internal;
1886
1887 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1888 typedef void InternalArenaConstructable_;
1889 typedef void DestructorSkippable_;
1890 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1891 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1892 ::webrtc::audioproc::Init* init_;
1893 ::webrtc::audioproc::ReverseStream* reverse_stream_;
1894 ::webrtc::audioproc::Stream* stream_;
1895 ::webrtc::audioproc::Config* config_;
1896 ::webrtc::audioproc::RuntimeSetting* runtime_setting_;
1897 int type_;
1898 friend struct ::TableStruct_debug_2eproto;
1899 };
1900 // ===================================================================
1901
1902
1903 // ===================================================================
1904
1905 #ifdef __GNUC__
1906 #pragma GCC diagnostic push
1907 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1908 #endif // __GNUC__
1909 // Init
1910
1911 // optional int32 sample_rate = 1;
_internal_has_sample_rate()1912 inline bool Init::_internal_has_sample_rate() const {
1913 bool value = (_has_bits_[0] & 0x00000001u) != 0;
1914 return value;
1915 }
has_sample_rate()1916 inline bool Init::has_sample_rate() const {
1917 return _internal_has_sample_rate();
1918 }
clear_sample_rate()1919 inline void Init::clear_sample_rate() {
1920 sample_rate_ = 0;
1921 _has_bits_[0] &= ~0x00000001u;
1922 }
_internal_sample_rate()1923 inline int32_t Init::_internal_sample_rate() const {
1924 return sample_rate_;
1925 }
sample_rate()1926 inline int32_t Init::sample_rate() const {
1927 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.sample_rate)
1928 return _internal_sample_rate();
1929 }
_internal_set_sample_rate(int32_t value)1930 inline void Init::_internal_set_sample_rate(int32_t value) {
1931 _has_bits_[0] |= 0x00000001u;
1932 sample_rate_ = value;
1933 }
set_sample_rate(int32_t value)1934 inline void Init::set_sample_rate(int32_t value) {
1935 _internal_set_sample_rate(value);
1936 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.sample_rate)
1937 }
1938
1939 // optional int32 device_sample_rate = 2 [deprecated = true];
_internal_has_device_sample_rate()1940 inline bool Init::_internal_has_device_sample_rate() const {
1941 bool value = (_has_bits_[0] & 0x00000002u) != 0;
1942 return value;
1943 }
has_device_sample_rate()1944 inline bool Init::has_device_sample_rate() const {
1945 return _internal_has_device_sample_rate();
1946 }
clear_device_sample_rate()1947 inline void Init::clear_device_sample_rate() {
1948 device_sample_rate_ = 0;
1949 _has_bits_[0] &= ~0x00000002u;
1950 }
_internal_device_sample_rate()1951 inline int32_t Init::_internal_device_sample_rate() const {
1952 return device_sample_rate_;
1953 }
device_sample_rate()1954 inline int32_t Init::device_sample_rate() const {
1955 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.device_sample_rate)
1956 return _internal_device_sample_rate();
1957 }
_internal_set_device_sample_rate(int32_t value)1958 inline void Init::_internal_set_device_sample_rate(int32_t value) {
1959 _has_bits_[0] |= 0x00000002u;
1960 device_sample_rate_ = value;
1961 }
set_device_sample_rate(int32_t value)1962 inline void Init::set_device_sample_rate(int32_t value) {
1963 _internal_set_device_sample_rate(value);
1964 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.device_sample_rate)
1965 }
1966
1967 // optional int32 num_input_channels = 3;
_internal_has_num_input_channels()1968 inline bool Init::_internal_has_num_input_channels() const {
1969 bool value = (_has_bits_[0] & 0x00000004u) != 0;
1970 return value;
1971 }
has_num_input_channels()1972 inline bool Init::has_num_input_channels() const {
1973 return _internal_has_num_input_channels();
1974 }
clear_num_input_channels()1975 inline void Init::clear_num_input_channels() {
1976 num_input_channels_ = 0;
1977 _has_bits_[0] &= ~0x00000004u;
1978 }
_internal_num_input_channels()1979 inline int32_t Init::_internal_num_input_channels() const {
1980 return num_input_channels_;
1981 }
num_input_channels()1982 inline int32_t Init::num_input_channels() const {
1983 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_input_channels)
1984 return _internal_num_input_channels();
1985 }
_internal_set_num_input_channels(int32_t value)1986 inline void Init::_internal_set_num_input_channels(int32_t value) {
1987 _has_bits_[0] |= 0x00000004u;
1988 num_input_channels_ = value;
1989 }
set_num_input_channels(int32_t value)1990 inline void Init::set_num_input_channels(int32_t value) {
1991 _internal_set_num_input_channels(value);
1992 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_input_channels)
1993 }
1994
1995 // optional int32 num_output_channels = 4;
_internal_has_num_output_channels()1996 inline bool Init::_internal_has_num_output_channels() const {
1997 bool value = (_has_bits_[0] & 0x00000008u) != 0;
1998 return value;
1999 }
has_num_output_channels()2000 inline bool Init::has_num_output_channels() const {
2001 return _internal_has_num_output_channels();
2002 }
clear_num_output_channels()2003 inline void Init::clear_num_output_channels() {
2004 num_output_channels_ = 0;
2005 _has_bits_[0] &= ~0x00000008u;
2006 }
_internal_num_output_channels()2007 inline int32_t Init::_internal_num_output_channels() const {
2008 return num_output_channels_;
2009 }
num_output_channels()2010 inline int32_t Init::num_output_channels() const {
2011 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_output_channels)
2012 return _internal_num_output_channels();
2013 }
_internal_set_num_output_channels(int32_t value)2014 inline void Init::_internal_set_num_output_channels(int32_t value) {
2015 _has_bits_[0] |= 0x00000008u;
2016 num_output_channels_ = value;
2017 }
set_num_output_channels(int32_t value)2018 inline void Init::set_num_output_channels(int32_t value) {
2019 _internal_set_num_output_channels(value);
2020 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_output_channels)
2021 }
2022
2023 // optional int32 num_reverse_channels = 5;
_internal_has_num_reverse_channels()2024 inline bool Init::_internal_has_num_reverse_channels() const {
2025 bool value = (_has_bits_[0] & 0x00000010u) != 0;
2026 return value;
2027 }
has_num_reverse_channels()2028 inline bool Init::has_num_reverse_channels() const {
2029 return _internal_has_num_reverse_channels();
2030 }
clear_num_reverse_channels()2031 inline void Init::clear_num_reverse_channels() {
2032 num_reverse_channels_ = 0;
2033 _has_bits_[0] &= ~0x00000010u;
2034 }
_internal_num_reverse_channels()2035 inline int32_t Init::_internal_num_reverse_channels() const {
2036 return num_reverse_channels_;
2037 }
num_reverse_channels()2038 inline int32_t Init::num_reverse_channels() const {
2039 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_reverse_channels)
2040 return _internal_num_reverse_channels();
2041 }
_internal_set_num_reverse_channels(int32_t value)2042 inline void Init::_internal_set_num_reverse_channels(int32_t value) {
2043 _has_bits_[0] |= 0x00000010u;
2044 num_reverse_channels_ = value;
2045 }
set_num_reverse_channels(int32_t value)2046 inline void Init::set_num_reverse_channels(int32_t value) {
2047 _internal_set_num_reverse_channels(value);
2048 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_reverse_channels)
2049 }
2050
2051 // optional int32 reverse_sample_rate = 6;
_internal_has_reverse_sample_rate()2052 inline bool Init::_internal_has_reverse_sample_rate() const {
2053 bool value = (_has_bits_[0] & 0x00000020u) != 0;
2054 return value;
2055 }
has_reverse_sample_rate()2056 inline bool Init::has_reverse_sample_rate() const {
2057 return _internal_has_reverse_sample_rate();
2058 }
clear_reverse_sample_rate()2059 inline void Init::clear_reverse_sample_rate() {
2060 reverse_sample_rate_ = 0;
2061 _has_bits_[0] &= ~0x00000020u;
2062 }
_internal_reverse_sample_rate()2063 inline int32_t Init::_internal_reverse_sample_rate() const {
2064 return reverse_sample_rate_;
2065 }
reverse_sample_rate()2066 inline int32_t Init::reverse_sample_rate() const {
2067 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.reverse_sample_rate)
2068 return _internal_reverse_sample_rate();
2069 }
_internal_set_reverse_sample_rate(int32_t value)2070 inline void Init::_internal_set_reverse_sample_rate(int32_t value) {
2071 _has_bits_[0] |= 0x00000020u;
2072 reverse_sample_rate_ = value;
2073 }
set_reverse_sample_rate(int32_t value)2074 inline void Init::set_reverse_sample_rate(int32_t value) {
2075 _internal_set_reverse_sample_rate(value);
2076 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.reverse_sample_rate)
2077 }
2078
2079 // optional int32 output_sample_rate = 7;
_internal_has_output_sample_rate()2080 inline bool Init::_internal_has_output_sample_rate() const {
2081 bool value = (_has_bits_[0] & 0x00000040u) != 0;
2082 return value;
2083 }
has_output_sample_rate()2084 inline bool Init::has_output_sample_rate() const {
2085 return _internal_has_output_sample_rate();
2086 }
clear_output_sample_rate()2087 inline void Init::clear_output_sample_rate() {
2088 output_sample_rate_ = 0;
2089 _has_bits_[0] &= ~0x00000040u;
2090 }
_internal_output_sample_rate()2091 inline int32_t Init::_internal_output_sample_rate() const {
2092 return output_sample_rate_;
2093 }
output_sample_rate()2094 inline int32_t Init::output_sample_rate() const {
2095 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.output_sample_rate)
2096 return _internal_output_sample_rate();
2097 }
_internal_set_output_sample_rate(int32_t value)2098 inline void Init::_internal_set_output_sample_rate(int32_t value) {
2099 _has_bits_[0] |= 0x00000040u;
2100 output_sample_rate_ = value;
2101 }
set_output_sample_rate(int32_t value)2102 inline void Init::set_output_sample_rate(int32_t value) {
2103 _internal_set_output_sample_rate(value);
2104 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.output_sample_rate)
2105 }
2106
2107 // optional int32 reverse_output_sample_rate = 8;
_internal_has_reverse_output_sample_rate()2108 inline bool Init::_internal_has_reverse_output_sample_rate() const {
2109 bool value = (_has_bits_[0] & 0x00000080u) != 0;
2110 return value;
2111 }
has_reverse_output_sample_rate()2112 inline bool Init::has_reverse_output_sample_rate() const {
2113 return _internal_has_reverse_output_sample_rate();
2114 }
clear_reverse_output_sample_rate()2115 inline void Init::clear_reverse_output_sample_rate() {
2116 reverse_output_sample_rate_ = 0;
2117 _has_bits_[0] &= ~0x00000080u;
2118 }
_internal_reverse_output_sample_rate()2119 inline int32_t Init::_internal_reverse_output_sample_rate() const {
2120 return reverse_output_sample_rate_;
2121 }
reverse_output_sample_rate()2122 inline int32_t Init::reverse_output_sample_rate() const {
2123 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.reverse_output_sample_rate)
2124 return _internal_reverse_output_sample_rate();
2125 }
_internal_set_reverse_output_sample_rate(int32_t value)2126 inline void Init::_internal_set_reverse_output_sample_rate(int32_t value) {
2127 _has_bits_[0] |= 0x00000080u;
2128 reverse_output_sample_rate_ = value;
2129 }
set_reverse_output_sample_rate(int32_t value)2130 inline void Init::set_reverse_output_sample_rate(int32_t value) {
2131 _internal_set_reverse_output_sample_rate(value);
2132 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.reverse_output_sample_rate)
2133 }
2134
2135 // optional int32 num_reverse_output_channels = 9;
_internal_has_num_reverse_output_channels()2136 inline bool Init::_internal_has_num_reverse_output_channels() const {
2137 bool value = (_has_bits_[0] & 0x00000200u) != 0;
2138 return value;
2139 }
has_num_reverse_output_channels()2140 inline bool Init::has_num_reverse_output_channels() const {
2141 return _internal_has_num_reverse_output_channels();
2142 }
clear_num_reverse_output_channels()2143 inline void Init::clear_num_reverse_output_channels() {
2144 num_reverse_output_channels_ = 0;
2145 _has_bits_[0] &= ~0x00000200u;
2146 }
_internal_num_reverse_output_channels()2147 inline int32_t Init::_internal_num_reverse_output_channels() const {
2148 return num_reverse_output_channels_;
2149 }
num_reverse_output_channels()2150 inline int32_t Init::num_reverse_output_channels() const {
2151 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.num_reverse_output_channels)
2152 return _internal_num_reverse_output_channels();
2153 }
_internal_set_num_reverse_output_channels(int32_t value)2154 inline void Init::_internal_set_num_reverse_output_channels(int32_t value) {
2155 _has_bits_[0] |= 0x00000200u;
2156 num_reverse_output_channels_ = value;
2157 }
set_num_reverse_output_channels(int32_t value)2158 inline void Init::set_num_reverse_output_channels(int32_t value) {
2159 _internal_set_num_reverse_output_channels(value);
2160 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.num_reverse_output_channels)
2161 }
2162
2163 // optional int64 timestamp_ms = 10;
_internal_has_timestamp_ms()2164 inline bool Init::_internal_has_timestamp_ms() const {
2165 bool value = (_has_bits_[0] & 0x00000100u) != 0;
2166 return value;
2167 }
has_timestamp_ms()2168 inline bool Init::has_timestamp_ms() const {
2169 return _internal_has_timestamp_ms();
2170 }
clear_timestamp_ms()2171 inline void Init::clear_timestamp_ms() {
2172 timestamp_ms_ = int64_t{0};
2173 _has_bits_[0] &= ~0x00000100u;
2174 }
_internal_timestamp_ms()2175 inline int64_t Init::_internal_timestamp_ms() const {
2176 return timestamp_ms_;
2177 }
timestamp_ms()2178 inline int64_t Init::timestamp_ms() const {
2179 // @@protoc_insertion_point(field_get:webrtc.audioproc.Init.timestamp_ms)
2180 return _internal_timestamp_ms();
2181 }
_internal_set_timestamp_ms(int64_t value)2182 inline void Init::_internal_set_timestamp_ms(int64_t value) {
2183 _has_bits_[0] |= 0x00000100u;
2184 timestamp_ms_ = value;
2185 }
set_timestamp_ms(int64_t value)2186 inline void Init::set_timestamp_ms(int64_t value) {
2187 _internal_set_timestamp_ms(value);
2188 // @@protoc_insertion_point(field_set:webrtc.audioproc.Init.timestamp_ms)
2189 }
2190
2191 // -------------------------------------------------------------------
2192
2193 // ReverseStream
2194
2195 // optional bytes data = 1;
_internal_has_data()2196 inline bool ReverseStream::_internal_has_data() const {
2197 bool value = (_has_bits_[0] & 0x00000001u) != 0;
2198 return value;
2199 }
has_data()2200 inline bool ReverseStream::has_data() const {
2201 return _internal_has_data();
2202 }
clear_data()2203 inline void ReverseStream::clear_data() {
2204 data_.ClearToEmpty();
2205 _has_bits_[0] &= ~0x00000001u;
2206 }
data()2207 inline const std::string& ReverseStream::data() const {
2208 // @@protoc_insertion_point(field_get:webrtc.audioproc.ReverseStream.data)
2209 return _internal_data();
2210 }
2211 template <typename ArgT0, typename... ArgT>
2212 inline PROTOBUF_ALWAYS_INLINE
set_data(ArgT0 && arg0,ArgT...args)2213 void ReverseStream::set_data(ArgT0&& arg0, ArgT... args) {
2214 _has_bits_[0] |= 0x00000001u;
2215 data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2216 // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.data)
2217 }
mutable_data()2218 inline std::string* ReverseStream::mutable_data() {
2219 std::string* _s = _internal_mutable_data();
2220 // @@protoc_insertion_point(field_mutable:webrtc.audioproc.ReverseStream.data)
2221 return _s;
2222 }
_internal_data()2223 inline const std::string& ReverseStream::_internal_data() const {
2224 return data_.Get();
2225 }
_internal_set_data(const std::string & value)2226 inline void ReverseStream::_internal_set_data(const std::string& value) {
2227 _has_bits_[0] |= 0x00000001u;
2228 data_.Set(value, GetArenaForAllocation());
2229 }
_internal_mutable_data()2230 inline std::string* ReverseStream::_internal_mutable_data() {
2231 _has_bits_[0] |= 0x00000001u;
2232 return data_.Mutable(GetArenaForAllocation());
2233 }
release_data()2234 inline std::string* ReverseStream::release_data() {
2235 // @@protoc_insertion_point(field_release:webrtc.audioproc.ReverseStream.data)
2236 if (!_internal_has_data()) {
2237 return nullptr;
2238 }
2239 _has_bits_[0] &= ~0x00000001u;
2240 auto* p = data_.Release();
2241 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2242 if (data_.IsDefault()) {
2243 data_.Set("", GetArenaForAllocation());
2244 }
2245 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2246 return p;
2247 }
set_allocated_data(std::string * data)2248 inline void ReverseStream::set_allocated_data(std::string* data) {
2249 if (data != nullptr) {
2250 _has_bits_[0] |= 0x00000001u;
2251 } else {
2252 _has_bits_[0] &= ~0x00000001u;
2253 }
2254 data_.SetAllocated(data, GetArenaForAllocation());
2255 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2256 if (data_.IsDefault()) {
2257 data_.Set("", GetArenaForAllocation());
2258 }
2259 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2260 // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.ReverseStream.data)
2261 }
2262
2263 // repeated bytes channel = 2;
_internal_channel_size()2264 inline int ReverseStream::_internal_channel_size() const {
2265 return channel_.size();
2266 }
channel_size()2267 inline int ReverseStream::channel_size() const {
2268 return _internal_channel_size();
2269 }
clear_channel()2270 inline void ReverseStream::clear_channel() {
2271 channel_.Clear();
2272 }
add_channel()2273 inline std::string* ReverseStream::add_channel() {
2274 std::string* _s = _internal_add_channel();
2275 // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.ReverseStream.channel)
2276 return _s;
2277 }
_internal_channel(int index)2278 inline const std::string& ReverseStream::_internal_channel(int index) const {
2279 return channel_.Get(index);
2280 }
channel(int index)2281 inline const std::string& ReverseStream::channel(int index) const {
2282 // @@protoc_insertion_point(field_get:webrtc.audioproc.ReverseStream.channel)
2283 return _internal_channel(index);
2284 }
mutable_channel(int index)2285 inline std::string* ReverseStream::mutable_channel(int index) {
2286 // @@protoc_insertion_point(field_mutable:webrtc.audioproc.ReverseStream.channel)
2287 return channel_.Mutable(index);
2288 }
set_channel(int index,const std::string & value)2289 inline void ReverseStream::set_channel(int index, const std::string& value) {
2290 channel_.Mutable(index)->assign(value);
2291 // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.channel)
2292 }
set_channel(int index,std::string && value)2293 inline void ReverseStream::set_channel(int index, std::string&& value) {
2294 channel_.Mutable(index)->assign(std::move(value));
2295 // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.channel)
2296 }
set_channel(int index,const char * value)2297 inline void ReverseStream::set_channel(int index, const char* value) {
2298 GOOGLE_DCHECK(value != nullptr);
2299 channel_.Mutable(index)->assign(value);
2300 // @@protoc_insertion_point(field_set_char:webrtc.audioproc.ReverseStream.channel)
2301 }
set_channel(int index,const void * value,size_t size)2302 inline void ReverseStream::set_channel(int index, const void* value, size_t size) {
2303 channel_.Mutable(index)->assign(
2304 reinterpret_cast<const char*>(value), size);
2305 // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.ReverseStream.channel)
2306 }
_internal_add_channel()2307 inline std::string* ReverseStream::_internal_add_channel() {
2308 return channel_.Add();
2309 }
add_channel(const std::string & value)2310 inline void ReverseStream::add_channel(const std::string& value) {
2311 channel_.Add()->assign(value);
2312 // @@protoc_insertion_point(field_add:webrtc.audioproc.ReverseStream.channel)
2313 }
add_channel(std::string && value)2314 inline void ReverseStream::add_channel(std::string&& value) {
2315 channel_.Add(std::move(value));
2316 // @@protoc_insertion_point(field_add:webrtc.audioproc.ReverseStream.channel)
2317 }
add_channel(const char * value)2318 inline void ReverseStream::add_channel(const char* value) {
2319 GOOGLE_DCHECK(value != nullptr);
2320 channel_.Add()->assign(value);
2321 // @@protoc_insertion_point(field_add_char:webrtc.audioproc.ReverseStream.channel)
2322 }
add_channel(const void * value,size_t size)2323 inline void ReverseStream::add_channel(const void* value, size_t size) {
2324 channel_.Add()->assign(reinterpret_cast<const char*>(value), size);
2325 // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.ReverseStream.channel)
2326 }
2327 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
channel()2328 ReverseStream::channel() const {
2329 // @@protoc_insertion_point(field_list:webrtc.audioproc.ReverseStream.channel)
2330 return channel_;
2331 }
2332 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_channel()2333 ReverseStream::mutable_channel() {
2334 // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.ReverseStream.channel)
2335 return &channel_;
2336 }
2337
2338 // -------------------------------------------------------------------
2339
2340 // Stream
2341
2342 // optional bytes input_data = 1;
_internal_has_input_data()2343 inline bool Stream::_internal_has_input_data() const {
2344 bool value = (_has_bits_[0] & 0x00000001u) != 0;
2345 return value;
2346 }
has_input_data()2347 inline bool Stream::has_input_data() const {
2348 return _internal_has_input_data();
2349 }
clear_input_data()2350 inline void Stream::clear_input_data() {
2351 input_data_.ClearToEmpty();
2352 _has_bits_[0] &= ~0x00000001u;
2353 }
input_data()2354 inline const std::string& Stream::input_data() const {
2355 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.input_data)
2356 return _internal_input_data();
2357 }
2358 template <typename ArgT0, typename... ArgT>
2359 inline PROTOBUF_ALWAYS_INLINE
set_input_data(ArgT0 && arg0,ArgT...args)2360 void Stream::set_input_data(ArgT0&& arg0, ArgT... args) {
2361 _has_bits_[0] |= 0x00000001u;
2362 input_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2363 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_data)
2364 }
mutable_input_data()2365 inline std::string* Stream::mutable_input_data() {
2366 std::string* _s = _internal_mutable_input_data();
2367 // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.input_data)
2368 return _s;
2369 }
_internal_input_data()2370 inline const std::string& Stream::_internal_input_data() const {
2371 return input_data_.Get();
2372 }
_internal_set_input_data(const std::string & value)2373 inline void Stream::_internal_set_input_data(const std::string& value) {
2374 _has_bits_[0] |= 0x00000001u;
2375 input_data_.Set(value, GetArenaForAllocation());
2376 }
_internal_mutable_input_data()2377 inline std::string* Stream::_internal_mutable_input_data() {
2378 _has_bits_[0] |= 0x00000001u;
2379 return input_data_.Mutable(GetArenaForAllocation());
2380 }
release_input_data()2381 inline std::string* Stream::release_input_data() {
2382 // @@protoc_insertion_point(field_release:webrtc.audioproc.Stream.input_data)
2383 if (!_internal_has_input_data()) {
2384 return nullptr;
2385 }
2386 _has_bits_[0] &= ~0x00000001u;
2387 auto* p = input_data_.Release();
2388 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2389 if (input_data_.IsDefault()) {
2390 input_data_.Set("", GetArenaForAllocation());
2391 }
2392 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2393 return p;
2394 }
set_allocated_input_data(std::string * input_data)2395 inline void Stream::set_allocated_input_data(std::string* input_data) {
2396 if (input_data != nullptr) {
2397 _has_bits_[0] |= 0x00000001u;
2398 } else {
2399 _has_bits_[0] &= ~0x00000001u;
2400 }
2401 input_data_.SetAllocated(input_data, GetArenaForAllocation());
2402 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2403 if (input_data_.IsDefault()) {
2404 input_data_.Set("", GetArenaForAllocation());
2405 }
2406 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2407 // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Stream.input_data)
2408 }
2409
2410 // optional bytes output_data = 2;
_internal_has_output_data()2411 inline bool Stream::_internal_has_output_data() const {
2412 bool value = (_has_bits_[0] & 0x00000002u) != 0;
2413 return value;
2414 }
has_output_data()2415 inline bool Stream::has_output_data() const {
2416 return _internal_has_output_data();
2417 }
clear_output_data()2418 inline void Stream::clear_output_data() {
2419 output_data_.ClearToEmpty();
2420 _has_bits_[0] &= ~0x00000002u;
2421 }
output_data()2422 inline const std::string& Stream::output_data() const {
2423 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.output_data)
2424 return _internal_output_data();
2425 }
2426 template <typename ArgT0, typename... ArgT>
2427 inline PROTOBUF_ALWAYS_INLINE
set_output_data(ArgT0 && arg0,ArgT...args)2428 void Stream::set_output_data(ArgT0&& arg0, ArgT... args) {
2429 _has_bits_[0] |= 0x00000002u;
2430 output_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2431 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_data)
2432 }
mutable_output_data()2433 inline std::string* Stream::mutable_output_data() {
2434 std::string* _s = _internal_mutable_output_data();
2435 // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.output_data)
2436 return _s;
2437 }
_internal_output_data()2438 inline const std::string& Stream::_internal_output_data() const {
2439 return output_data_.Get();
2440 }
_internal_set_output_data(const std::string & value)2441 inline void Stream::_internal_set_output_data(const std::string& value) {
2442 _has_bits_[0] |= 0x00000002u;
2443 output_data_.Set(value, GetArenaForAllocation());
2444 }
_internal_mutable_output_data()2445 inline std::string* Stream::_internal_mutable_output_data() {
2446 _has_bits_[0] |= 0x00000002u;
2447 return output_data_.Mutable(GetArenaForAllocation());
2448 }
release_output_data()2449 inline std::string* Stream::release_output_data() {
2450 // @@protoc_insertion_point(field_release:webrtc.audioproc.Stream.output_data)
2451 if (!_internal_has_output_data()) {
2452 return nullptr;
2453 }
2454 _has_bits_[0] &= ~0x00000002u;
2455 auto* p = output_data_.Release();
2456 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2457 if (output_data_.IsDefault()) {
2458 output_data_.Set("", GetArenaForAllocation());
2459 }
2460 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2461 return p;
2462 }
set_allocated_output_data(std::string * output_data)2463 inline void Stream::set_allocated_output_data(std::string* output_data) {
2464 if (output_data != nullptr) {
2465 _has_bits_[0] |= 0x00000002u;
2466 } else {
2467 _has_bits_[0] &= ~0x00000002u;
2468 }
2469 output_data_.SetAllocated(output_data, GetArenaForAllocation());
2470 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2471 if (output_data_.IsDefault()) {
2472 output_data_.Set("", GetArenaForAllocation());
2473 }
2474 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2475 // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Stream.output_data)
2476 }
2477
2478 // optional int32 delay = 3;
_internal_has_delay()2479 inline bool Stream::_internal_has_delay() const {
2480 bool value = (_has_bits_[0] & 0x00000004u) != 0;
2481 return value;
2482 }
has_delay()2483 inline bool Stream::has_delay() const {
2484 return _internal_has_delay();
2485 }
clear_delay()2486 inline void Stream::clear_delay() {
2487 delay_ = 0;
2488 _has_bits_[0] &= ~0x00000004u;
2489 }
_internal_delay()2490 inline int32_t Stream::_internal_delay() const {
2491 return delay_;
2492 }
delay()2493 inline int32_t Stream::delay() const {
2494 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.delay)
2495 return _internal_delay();
2496 }
_internal_set_delay(int32_t value)2497 inline void Stream::_internal_set_delay(int32_t value) {
2498 _has_bits_[0] |= 0x00000004u;
2499 delay_ = value;
2500 }
set_delay(int32_t value)2501 inline void Stream::set_delay(int32_t value) {
2502 _internal_set_delay(value);
2503 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.delay)
2504 }
2505
2506 // optional sint32 drift = 4;
_internal_has_drift()2507 inline bool Stream::_internal_has_drift() const {
2508 bool value = (_has_bits_[0] & 0x00000008u) != 0;
2509 return value;
2510 }
has_drift()2511 inline bool Stream::has_drift() const {
2512 return _internal_has_drift();
2513 }
clear_drift()2514 inline void Stream::clear_drift() {
2515 drift_ = 0;
2516 _has_bits_[0] &= ~0x00000008u;
2517 }
_internal_drift()2518 inline int32_t Stream::_internal_drift() const {
2519 return drift_;
2520 }
drift()2521 inline int32_t Stream::drift() const {
2522 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.drift)
2523 return _internal_drift();
2524 }
_internal_set_drift(int32_t value)2525 inline void Stream::_internal_set_drift(int32_t value) {
2526 _has_bits_[0] |= 0x00000008u;
2527 drift_ = value;
2528 }
set_drift(int32_t value)2529 inline void Stream::set_drift(int32_t value) {
2530 _internal_set_drift(value);
2531 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.drift)
2532 }
2533
2534 // optional int32 applied_input_volume = 5;
_internal_has_applied_input_volume()2535 inline bool Stream::_internal_has_applied_input_volume() const {
2536 bool value = (_has_bits_[0] & 0x00000010u) != 0;
2537 return value;
2538 }
has_applied_input_volume()2539 inline bool Stream::has_applied_input_volume() const {
2540 return _internal_has_applied_input_volume();
2541 }
clear_applied_input_volume()2542 inline void Stream::clear_applied_input_volume() {
2543 applied_input_volume_ = 0;
2544 _has_bits_[0] &= ~0x00000010u;
2545 }
_internal_applied_input_volume()2546 inline int32_t Stream::_internal_applied_input_volume() const {
2547 return applied_input_volume_;
2548 }
applied_input_volume()2549 inline int32_t Stream::applied_input_volume() const {
2550 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.applied_input_volume)
2551 return _internal_applied_input_volume();
2552 }
_internal_set_applied_input_volume(int32_t value)2553 inline void Stream::_internal_set_applied_input_volume(int32_t value) {
2554 _has_bits_[0] |= 0x00000010u;
2555 applied_input_volume_ = value;
2556 }
set_applied_input_volume(int32_t value)2557 inline void Stream::set_applied_input_volume(int32_t value) {
2558 _internal_set_applied_input_volume(value);
2559 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.applied_input_volume)
2560 }
2561
2562 // optional bool keypress = 6;
_internal_has_keypress()2563 inline bool Stream::_internal_has_keypress() const {
2564 bool value = (_has_bits_[0] & 0x00000020u) != 0;
2565 return value;
2566 }
has_keypress()2567 inline bool Stream::has_keypress() const {
2568 return _internal_has_keypress();
2569 }
clear_keypress()2570 inline void Stream::clear_keypress() {
2571 keypress_ = false;
2572 _has_bits_[0] &= ~0x00000020u;
2573 }
_internal_keypress()2574 inline bool Stream::_internal_keypress() const {
2575 return keypress_;
2576 }
keypress()2577 inline bool Stream::keypress() const {
2578 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.keypress)
2579 return _internal_keypress();
2580 }
_internal_set_keypress(bool value)2581 inline void Stream::_internal_set_keypress(bool value) {
2582 _has_bits_[0] |= 0x00000020u;
2583 keypress_ = value;
2584 }
set_keypress(bool value)2585 inline void Stream::set_keypress(bool value) {
2586 _internal_set_keypress(value);
2587 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.keypress)
2588 }
2589
2590 // repeated bytes input_channel = 7;
_internal_input_channel_size()2591 inline int Stream::_internal_input_channel_size() const {
2592 return input_channel_.size();
2593 }
input_channel_size()2594 inline int Stream::input_channel_size() const {
2595 return _internal_input_channel_size();
2596 }
clear_input_channel()2597 inline void Stream::clear_input_channel() {
2598 input_channel_.Clear();
2599 }
add_input_channel()2600 inline std::string* Stream::add_input_channel() {
2601 std::string* _s = _internal_add_input_channel();
2602 // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.Stream.input_channel)
2603 return _s;
2604 }
_internal_input_channel(int index)2605 inline const std::string& Stream::_internal_input_channel(int index) const {
2606 return input_channel_.Get(index);
2607 }
input_channel(int index)2608 inline const std::string& Stream::input_channel(int index) const {
2609 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.input_channel)
2610 return _internal_input_channel(index);
2611 }
mutable_input_channel(int index)2612 inline std::string* Stream::mutable_input_channel(int index) {
2613 // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.input_channel)
2614 return input_channel_.Mutable(index);
2615 }
set_input_channel(int index,const std::string & value)2616 inline void Stream::set_input_channel(int index, const std::string& value) {
2617 input_channel_.Mutable(index)->assign(value);
2618 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_channel)
2619 }
set_input_channel(int index,std::string && value)2620 inline void Stream::set_input_channel(int index, std::string&& value) {
2621 input_channel_.Mutable(index)->assign(std::move(value));
2622 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_channel)
2623 }
set_input_channel(int index,const char * value)2624 inline void Stream::set_input_channel(int index, const char* value) {
2625 GOOGLE_DCHECK(value != nullptr);
2626 input_channel_.Mutable(index)->assign(value);
2627 // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.input_channel)
2628 }
set_input_channel(int index,const void * value,size_t size)2629 inline void Stream::set_input_channel(int index, const void* value, size_t size) {
2630 input_channel_.Mutable(index)->assign(
2631 reinterpret_cast<const char*>(value), size);
2632 // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.input_channel)
2633 }
_internal_add_input_channel()2634 inline std::string* Stream::_internal_add_input_channel() {
2635 return input_channel_.Add();
2636 }
add_input_channel(const std::string & value)2637 inline void Stream::add_input_channel(const std::string& value) {
2638 input_channel_.Add()->assign(value);
2639 // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.input_channel)
2640 }
add_input_channel(std::string && value)2641 inline void Stream::add_input_channel(std::string&& value) {
2642 input_channel_.Add(std::move(value));
2643 // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.input_channel)
2644 }
add_input_channel(const char * value)2645 inline void Stream::add_input_channel(const char* value) {
2646 GOOGLE_DCHECK(value != nullptr);
2647 input_channel_.Add()->assign(value);
2648 // @@protoc_insertion_point(field_add_char:webrtc.audioproc.Stream.input_channel)
2649 }
add_input_channel(const void * value,size_t size)2650 inline void Stream::add_input_channel(const void* value, size_t size) {
2651 input_channel_.Add()->assign(reinterpret_cast<const char*>(value), size);
2652 // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.Stream.input_channel)
2653 }
2654 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
input_channel()2655 Stream::input_channel() const {
2656 // @@protoc_insertion_point(field_list:webrtc.audioproc.Stream.input_channel)
2657 return input_channel_;
2658 }
2659 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_input_channel()2660 Stream::mutable_input_channel() {
2661 // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.Stream.input_channel)
2662 return &input_channel_;
2663 }
2664
2665 // repeated bytes output_channel = 8;
_internal_output_channel_size()2666 inline int Stream::_internal_output_channel_size() const {
2667 return output_channel_.size();
2668 }
output_channel_size()2669 inline int Stream::output_channel_size() const {
2670 return _internal_output_channel_size();
2671 }
clear_output_channel()2672 inline void Stream::clear_output_channel() {
2673 output_channel_.Clear();
2674 }
add_output_channel()2675 inline std::string* Stream::add_output_channel() {
2676 std::string* _s = _internal_add_output_channel();
2677 // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.Stream.output_channel)
2678 return _s;
2679 }
_internal_output_channel(int index)2680 inline const std::string& Stream::_internal_output_channel(int index) const {
2681 return output_channel_.Get(index);
2682 }
output_channel(int index)2683 inline const std::string& Stream::output_channel(int index) const {
2684 // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.output_channel)
2685 return _internal_output_channel(index);
2686 }
mutable_output_channel(int index)2687 inline std::string* Stream::mutable_output_channel(int index) {
2688 // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.output_channel)
2689 return output_channel_.Mutable(index);
2690 }
set_output_channel(int index,const std::string & value)2691 inline void Stream::set_output_channel(int index, const std::string& value) {
2692 output_channel_.Mutable(index)->assign(value);
2693 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_channel)
2694 }
set_output_channel(int index,std::string && value)2695 inline void Stream::set_output_channel(int index, std::string&& value) {
2696 output_channel_.Mutable(index)->assign(std::move(value));
2697 // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_channel)
2698 }
set_output_channel(int index,const char * value)2699 inline void Stream::set_output_channel(int index, const char* value) {
2700 GOOGLE_DCHECK(value != nullptr);
2701 output_channel_.Mutable(index)->assign(value);
2702 // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.output_channel)
2703 }
set_output_channel(int index,const void * value,size_t size)2704 inline void Stream::set_output_channel(int index, const void* value, size_t size) {
2705 output_channel_.Mutable(index)->assign(
2706 reinterpret_cast<const char*>(value), size);
2707 // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.output_channel)
2708 }
_internal_add_output_channel()2709 inline std::string* Stream::_internal_add_output_channel() {
2710 return output_channel_.Add();
2711 }
add_output_channel(const std::string & value)2712 inline void Stream::add_output_channel(const std::string& value) {
2713 output_channel_.Add()->assign(value);
2714 // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.output_channel)
2715 }
add_output_channel(std::string && value)2716 inline void Stream::add_output_channel(std::string&& value) {
2717 output_channel_.Add(std::move(value));
2718 // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.output_channel)
2719 }
add_output_channel(const char * value)2720 inline void Stream::add_output_channel(const char* value) {
2721 GOOGLE_DCHECK(value != nullptr);
2722 output_channel_.Add()->assign(value);
2723 // @@protoc_insertion_point(field_add_char:webrtc.audioproc.Stream.output_channel)
2724 }
add_output_channel(const void * value,size_t size)2725 inline void Stream::add_output_channel(const void* value, size_t size) {
2726 output_channel_.Add()->assign(reinterpret_cast<const char*>(value), size);
2727 // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.Stream.output_channel)
2728 }
2729 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
output_channel()2730 Stream::output_channel() const {
2731 // @@protoc_insertion_point(field_list:webrtc.audioproc.Stream.output_channel)
2732 return output_channel_;
2733 }
2734 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_output_channel()2735 Stream::mutable_output_channel() {
2736 // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.Stream.output_channel)
2737 return &output_channel_;
2738 }
2739
2740 // -------------------------------------------------------------------
2741
2742 // Config
2743
2744 // optional bool aec_enabled = 1;
_internal_has_aec_enabled()2745 inline bool Config::_internal_has_aec_enabled() const {
2746 bool value = (_has_bits_[0] & 0x00000002u) != 0;
2747 return value;
2748 }
has_aec_enabled()2749 inline bool Config::has_aec_enabled() const {
2750 return _internal_has_aec_enabled();
2751 }
clear_aec_enabled()2752 inline void Config::clear_aec_enabled() {
2753 aec_enabled_ = false;
2754 _has_bits_[0] &= ~0x00000002u;
2755 }
_internal_aec_enabled()2756 inline bool Config::_internal_aec_enabled() const {
2757 return aec_enabled_;
2758 }
aec_enabled()2759 inline bool Config::aec_enabled() const {
2760 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_enabled)
2761 return _internal_aec_enabled();
2762 }
_internal_set_aec_enabled(bool value)2763 inline void Config::_internal_set_aec_enabled(bool value) {
2764 _has_bits_[0] |= 0x00000002u;
2765 aec_enabled_ = value;
2766 }
set_aec_enabled(bool value)2767 inline void Config::set_aec_enabled(bool value) {
2768 _internal_set_aec_enabled(value);
2769 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_enabled)
2770 }
2771
2772 // optional bool aec_delay_agnostic_enabled = 2;
_internal_has_aec_delay_agnostic_enabled()2773 inline bool Config::_internal_has_aec_delay_agnostic_enabled() const {
2774 bool value = (_has_bits_[0] & 0x00000004u) != 0;
2775 return value;
2776 }
has_aec_delay_agnostic_enabled()2777 inline bool Config::has_aec_delay_agnostic_enabled() const {
2778 return _internal_has_aec_delay_agnostic_enabled();
2779 }
clear_aec_delay_agnostic_enabled()2780 inline void Config::clear_aec_delay_agnostic_enabled() {
2781 aec_delay_agnostic_enabled_ = false;
2782 _has_bits_[0] &= ~0x00000004u;
2783 }
_internal_aec_delay_agnostic_enabled()2784 inline bool Config::_internal_aec_delay_agnostic_enabled() const {
2785 return aec_delay_agnostic_enabled_;
2786 }
aec_delay_agnostic_enabled()2787 inline bool Config::aec_delay_agnostic_enabled() const {
2788 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_delay_agnostic_enabled)
2789 return _internal_aec_delay_agnostic_enabled();
2790 }
_internal_set_aec_delay_agnostic_enabled(bool value)2791 inline void Config::_internal_set_aec_delay_agnostic_enabled(bool value) {
2792 _has_bits_[0] |= 0x00000004u;
2793 aec_delay_agnostic_enabled_ = value;
2794 }
set_aec_delay_agnostic_enabled(bool value)2795 inline void Config::set_aec_delay_agnostic_enabled(bool value) {
2796 _internal_set_aec_delay_agnostic_enabled(value);
2797 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_delay_agnostic_enabled)
2798 }
2799
2800 // optional bool aec_drift_compensation_enabled = 3;
_internal_has_aec_drift_compensation_enabled()2801 inline bool Config::_internal_has_aec_drift_compensation_enabled() const {
2802 bool value = (_has_bits_[0] & 0x00000008u) != 0;
2803 return value;
2804 }
has_aec_drift_compensation_enabled()2805 inline bool Config::has_aec_drift_compensation_enabled() const {
2806 return _internal_has_aec_drift_compensation_enabled();
2807 }
clear_aec_drift_compensation_enabled()2808 inline void Config::clear_aec_drift_compensation_enabled() {
2809 aec_drift_compensation_enabled_ = false;
2810 _has_bits_[0] &= ~0x00000008u;
2811 }
_internal_aec_drift_compensation_enabled()2812 inline bool Config::_internal_aec_drift_compensation_enabled() const {
2813 return aec_drift_compensation_enabled_;
2814 }
aec_drift_compensation_enabled()2815 inline bool Config::aec_drift_compensation_enabled() const {
2816 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_drift_compensation_enabled)
2817 return _internal_aec_drift_compensation_enabled();
2818 }
_internal_set_aec_drift_compensation_enabled(bool value)2819 inline void Config::_internal_set_aec_drift_compensation_enabled(bool value) {
2820 _has_bits_[0] |= 0x00000008u;
2821 aec_drift_compensation_enabled_ = value;
2822 }
set_aec_drift_compensation_enabled(bool value)2823 inline void Config::set_aec_drift_compensation_enabled(bool value) {
2824 _internal_set_aec_drift_compensation_enabled(value);
2825 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_drift_compensation_enabled)
2826 }
2827
2828 // optional bool aec_extended_filter_enabled = 4;
_internal_has_aec_extended_filter_enabled()2829 inline bool Config::_internal_has_aec_extended_filter_enabled() const {
2830 bool value = (_has_bits_[0] & 0x00000010u) != 0;
2831 return value;
2832 }
has_aec_extended_filter_enabled()2833 inline bool Config::has_aec_extended_filter_enabled() const {
2834 return _internal_has_aec_extended_filter_enabled();
2835 }
clear_aec_extended_filter_enabled()2836 inline void Config::clear_aec_extended_filter_enabled() {
2837 aec_extended_filter_enabled_ = false;
2838 _has_bits_[0] &= ~0x00000010u;
2839 }
_internal_aec_extended_filter_enabled()2840 inline bool Config::_internal_aec_extended_filter_enabled() const {
2841 return aec_extended_filter_enabled_;
2842 }
aec_extended_filter_enabled()2843 inline bool Config::aec_extended_filter_enabled() const {
2844 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_extended_filter_enabled)
2845 return _internal_aec_extended_filter_enabled();
2846 }
_internal_set_aec_extended_filter_enabled(bool value)2847 inline void Config::_internal_set_aec_extended_filter_enabled(bool value) {
2848 _has_bits_[0] |= 0x00000010u;
2849 aec_extended_filter_enabled_ = value;
2850 }
set_aec_extended_filter_enabled(bool value)2851 inline void Config::set_aec_extended_filter_enabled(bool value) {
2852 _internal_set_aec_extended_filter_enabled(value);
2853 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_extended_filter_enabled)
2854 }
2855
2856 // optional int32 aec_suppression_level = 5;
_internal_has_aec_suppression_level()2857 inline bool Config::_internal_has_aec_suppression_level() const {
2858 bool value = (_has_bits_[0] & 0x00000020u) != 0;
2859 return value;
2860 }
has_aec_suppression_level()2861 inline bool Config::has_aec_suppression_level() const {
2862 return _internal_has_aec_suppression_level();
2863 }
clear_aec_suppression_level()2864 inline void Config::clear_aec_suppression_level() {
2865 aec_suppression_level_ = 0;
2866 _has_bits_[0] &= ~0x00000020u;
2867 }
_internal_aec_suppression_level()2868 inline int32_t Config::_internal_aec_suppression_level() const {
2869 return aec_suppression_level_;
2870 }
aec_suppression_level()2871 inline int32_t Config::aec_suppression_level() const {
2872 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aec_suppression_level)
2873 return _internal_aec_suppression_level();
2874 }
_internal_set_aec_suppression_level(int32_t value)2875 inline void Config::_internal_set_aec_suppression_level(int32_t value) {
2876 _has_bits_[0] |= 0x00000020u;
2877 aec_suppression_level_ = value;
2878 }
set_aec_suppression_level(int32_t value)2879 inline void Config::set_aec_suppression_level(int32_t value) {
2880 _internal_set_aec_suppression_level(value);
2881 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aec_suppression_level)
2882 }
2883
2884 // optional bool aecm_enabled = 6;
_internal_has_aecm_enabled()2885 inline bool Config::_internal_has_aecm_enabled() const {
2886 bool value = (_has_bits_[0] & 0x00000080u) != 0;
2887 return value;
2888 }
has_aecm_enabled()2889 inline bool Config::has_aecm_enabled() const {
2890 return _internal_has_aecm_enabled();
2891 }
clear_aecm_enabled()2892 inline void Config::clear_aecm_enabled() {
2893 aecm_enabled_ = false;
2894 _has_bits_[0] &= ~0x00000080u;
2895 }
_internal_aecm_enabled()2896 inline bool Config::_internal_aecm_enabled() const {
2897 return aecm_enabled_;
2898 }
aecm_enabled()2899 inline bool Config::aecm_enabled() const {
2900 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aecm_enabled)
2901 return _internal_aecm_enabled();
2902 }
_internal_set_aecm_enabled(bool value)2903 inline void Config::_internal_set_aecm_enabled(bool value) {
2904 _has_bits_[0] |= 0x00000080u;
2905 aecm_enabled_ = value;
2906 }
set_aecm_enabled(bool value)2907 inline void Config::set_aecm_enabled(bool value) {
2908 _internal_set_aecm_enabled(value);
2909 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aecm_enabled)
2910 }
2911
2912 // optional bool aecm_comfort_noise_enabled = 7 [deprecated = true];
_internal_has_aecm_comfort_noise_enabled()2913 inline bool Config::_internal_has_aecm_comfort_noise_enabled() const {
2914 bool value = (_has_bits_[0] & 0x00000100u) != 0;
2915 return value;
2916 }
has_aecm_comfort_noise_enabled()2917 inline bool Config::has_aecm_comfort_noise_enabled() const {
2918 return _internal_has_aecm_comfort_noise_enabled();
2919 }
clear_aecm_comfort_noise_enabled()2920 inline void Config::clear_aecm_comfort_noise_enabled() {
2921 aecm_comfort_noise_enabled_ = false;
2922 _has_bits_[0] &= ~0x00000100u;
2923 }
_internal_aecm_comfort_noise_enabled()2924 inline bool Config::_internal_aecm_comfort_noise_enabled() const {
2925 return aecm_comfort_noise_enabled_;
2926 }
aecm_comfort_noise_enabled()2927 inline bool Config::aecm_comfort_noise_enabled() const {
2928 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aecm_comfort_noise_enabled)
2929 return _internal_aecm_comfort_noise_enabled();
2930 }
_internal_set_aecm_comfort_noise_enabled(bool value)2931 inline void Config::_internal_set_aecm_comfort_noise_enabled(bool value) {
2932 _has_bits_[0] |= 0x00000100u;
2933 aecm_comfort_noise_enabled_ = value;
2934 }
set_aecm_comfort_noise_enabled(bool value)2935 inline void Config::set_aecm_comfort_noise_enabled(bool value) {
2936 _internal_set_aecm_comfort_noise_enabled(value);
2937 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aecm_comfort_noise_enabled)
2938 }
2939
2940 // optional int32 aecm_routing_mode = 8 [deprecated = true];
_internal_has_aecm_routing_mode()2941 inline bool Config::_internal_has_aecm_routing_mode() const {
2942 bool value = (_has_bits_[0] & 0x00000040u) != 0;
2943 return value;
2944 }
has_aecm_routing_mode()2945 inline bool Config::has_aecm_routing_mode() const {
2946 return _internal_has_aecm_routing_mode();
2947 }
clear_aecm_routing_mode()2948 inline void Config::clear_aecm_routing_mode() {
2949 aecm_routing_mode_ = 0;
2950 _has_bits_[0] &= ~0x00000040u;
2951 }
_internal_aecm_routing_mode()2952 inline int32_t Config::_internal_aecm_routing_mode() const {
2953 return aecm_routing_mode_;
2954 }
aecm_routing_mode()2955 inline int32_t Config::aecm_routing_mode() const {
2956 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.aecm_routing_mode)
2957 return _internal_aecm_routing_mode();
2958 }
_internal_set_aecm_routing_mode(int32_t value)2959 inline void Config::_internal_set_aecm_routing_mode(int32_t value) {
2960 _has_bits_[0] |= 0x00000040u;
2961 aecm_routing_mode_ = value;
2962 }
set_aecm_routing_mode(int32_t value)2963 inline void Config::set_aecm_routing_mode(int32_t value) {
2964 _internal_set_aecm_routing_mode(value);
2965 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.aecm_routing_mode)
2966 }
2967
2968 // optional bool agc_enabled = 9;
_internal_has_agc_enabled()2969 inline bool Config::_internal_has_agc_enabled() const {
2970 bool value = (_has_bits_[0] & 0x00000200u) != 0;
2971 return value;
2972 }
has_agc_enabled()2973 inline bool Config::has_agc_enabled() const {
2974 return _internal_has_agc_enabled();
2975 }
clear_agc_enabled()2976 inline void Config::clear_agc_enabled() {
2977 agc_enabled_ = false;
2978 _has_bits_[0] &= ~0x00000200u;
2979 }
_internal_agc_enabled()2980 inline bool Config::_internal_agc_enabled() const {
2981 return agc_enabled_;
2982 }
agc_enabled()2983 inline bool Config::agc_enabled() const {
2984 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.agc_enabled)
2985 return _internal_agc_enabled();
2986 }
_internal_set_agc_enabled(bool value)2987 inline void Config::_internal_set_agc_enabled(bool value) {
2988 _has_bits_[0] |= 0x00000200u;
2989 agc_enabled_ = value;
2990 }
set_agc_enabled(bool value)2991 inline void Config::set_agc_enabled(bool value) {
2992 _internal_set_agc_enabled(value);
2993 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.agc_enabled)
2994 }
2995
2996 // optional int32 agc_mode = 10;
_internal_has_agc_mode()2997 inline bool Config::_internal_has_agc_mode() const {
2998 bool value = (_has_bits_[0] & 0x00000800u) != 0;
2999 return value;
3000 }
has_agc_mode()3001 inline bool Config::has_agc_mode() const {
3002 return _internal_has_agc_mode();
3003 }
clear_agc_mode()3004 inline void Config::clear_agc_mode() {
3005 agc_mode_ = 0;
3006 _has_bits_[0] &= ~0x00000800u;
3007 }
_internal_agc_mode()3008 inline int32_t Config::_internal_agc_mode() const {
3009 return agc_mode_;
3010 }
agc_mode()3011 inline int32_t Config::agc_mode() const {
3012 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.agc_mode)
3013 return _internal_agc_mode();
3014 }
_internal_set_agc_mode(int32_t value)3015 inline void Config::_internal_set_agc_mode(int32_t value) {
3016 _has_bits_[0] |= 0x00000800u;
3017 agc_mode_ = value;
3018 }
set_agc_mode(int32_t value)3019 inline void Config::set_agc_mode(int32_t value) {
3020 _internal_set_agc_mode(value);
3021 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.agc_mode)
3022 }
3023
3024 // optional bool agc_limiter_enabled = 11;
_internal_has_agc_limiter_enabled()3025 inline bool Config::_internal_has_agc_limiter_enabled() const {
3026 bool value = (_has_bits_[0] & 0x00000400u) != 0;
3027 return value;
3028 }
has_agc_limiter_enabled()3029 inline bool Config::has_agc_limiter_enabled() const {
3030 return _internal_has_agc_limiter_enabled();
3031 }
clear_agc_limiter_enabled()3032 inline void Config::clear_agc_limiter_enabled() {
3033 agc_limiter_enabled_ = false;
3034 _has_bits_[0] &= ~0x00000400u;
3035 }
_internal_agc_limiter_enabled()3036 inline bool Config::_internal_agc_limiter_enabled() const {
3037 return agc_limiter_enabled_;
3038 }
agc_limiter_enabled()3039 inline bool Config::agc_limiter_enabled() const {
3040 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.agc_limiter_enabled)
3041 return _internal_agc_limiter_enabled();
3042 }
_internal_set_agc_limiter_enabled(bool value)3043 inline void Config::_internal_set_agc_limiter_enabled(bool value) {
3044 _has_bits_[0] |= 0x00000400u;
3045 agc_limiter_enabled_ = value;
3046 }
set_agc_limiter_enabled(bool value)3047 inline void Config::set_agc_limiter_enabled(bool value) {
3048 _internal_set_agc_limiter_enabled(value);
3049 // @@protoc_insertion_point(field_set:webrtc.audioproc.Config.agc_limiter_enabled)
3050 }
3051
3052 // optional bool noise_robust_agc_enabled = 12;
_internal_has_noise_robust_agc_enabled()3053 inline bool Config::_internal_has_noise_robust_agc_enabled() const {
3054 bool value = (_has_bits_[0] & 0x00001000u) != 0;
3055 return value;
3056 }
has_noise_robust_agc_enabled()3057 inline bool Config::has_noise_robust_agc_enabled() const {
3058 return _internal_has_noise_robust_agc_enabled();
3059 }
clear_noise_robust_agc_enabled()3060 inline void Config::clear_noise_robust_agc_enabled() {
3061 noise_robust_agc_enabled_ = false;
3062 _has_bits_[0] &= ~0x00001000u;
3063 }
_internal_noise_robust_agc_enabled()3064 inline bool Config::_internal_noise_robust_agc_enabled() const {
3065 return noise_robust_agc_enabled_;
3066 }
noise_robust_agc_enabled()3067 inline bool Config::noise_robust_agc_enabled() const {
3068 // @@protoc_insertion_point(field_get:webrtc.audioproc.Config.noise_robust_agc_enabled)
3069 return _internal_noise_robust_agc_enabled();
3070 }
_internal_set_noise_robust_agc_enabled(bool value)3071