1 /* 2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef VOICE_ENGINE_CHANNEL_MANAGER_H_ 12 #define VOICE_ENGINE_CHANNEL_MANAGER_H_ 13 14 #include <memory> 15 #include <vector> 16 17 #include "api/refcountedbase.h" 18 #include "rtc_base/constructormagic.h" 19 #include "rtc_base/criticalsection.h" 20 #include "rtc_base/random.h" 21 #include "rtc_base/scoped_ref_ptr.h" 22 #include "system_wrappers/include/atomic32.h" 23 #include "typedefs.h" // NOLINT(build/include) 24 #include "voice_engine/include/voe_base.h" 25 26 namespace webrtc { 27 28 class AudioDecoderFactory; 29 30 namespace voe { 31 32 class Channel; 33 34 // Shared-pointer implementation for keeping track of Channels. The underlying 35 // shared instance will be dropped when no more ChannelOwners point to it. 36 // 37 // One common source of ChannelOwner instances are 38 // ChannelManager::CreateChannel() and ChannelManager::GetChannel(...). 39 // It has a similar use case to shared_ptr in C++11. Should this move to C++11 40 // in the future, this class should be replaced by exactly that. 41 // 42 // To access the underlying Channel, use .channel(). 43 // IsValid() implements a convenience method as an alternative for checking 44 // whether the underlying pointer is NULL or not. 45 // 46 // Channel channel_owner = channel_manager.GetChannel(channel_id); 47 // if (channel_owner.IsValid()) 48 // channel_owner.channel()->...; 49 // 50 class ChannelOwner { 51 public: 52 explicit ChannelOwner(Channel* channel); 53 ChannelOwner(const ChannelOwner& channel_owner) = default; 54 55 ~ChannelOwner() = default; 56 57 ChannelOwner& operator=(const ChannelOwner& other) = default; 58 channel()59 Channel* channel() const { return channel_ref_->channel.get(); } IsValid()60 bool IsValid() { return channel_ref_->channel.get() != NULL; } 61 private: 62 // Shared instance of a Channel. Copying ChannelOwners increase the reference 63 // count and destroying ChannelOwners decrease references. Channels are 64 // deleted when no references to them are held. 65 struct ChannelRef : public rtc::RefCountedBase { 66 ChannelRef(Channel* channel); 67 const std::unique_ptr<Channel> channel; 68 }; 69 70 rtc::scoped_refptr<ChannelRef> channel_ref_; 71 }; 72 73 class ChannelManager { 74 public: 75 ChannelManager(uint32_t instance_id); 76 77 // Upon construction of an Iterator it will grab a copy of the channel list of 78 // the ChannelManager. The iteration will then occur over this state, not the 79 // current one of the ChannelManager. As the Iterator holds its own references 80 // to the Channels, they will remain valid even if they are removed from the 81 // ChannelManager. 82 class Iterator { 83 public: 84 explicit Iterator(ChannelManager* channel_manager); 85 86 Channel* GetChannel(); 87 bool IsValid(); 88 89 void Increment(); 90 91 private: 92 size_t iterator_pos_; 93 std::vector<ChannelOwner> channels_; 94 95 RTC_DISALLOW_COPY_AND_ASSIGN(Iterator); 96 }; 97 98 // CreateChannel will always return a valid ChannelOwner instance. 99 ChannelOwner CreateChannel(const VoEBase::ChannelConfig& config); 100 101 // ChannelOwner.channel() will be NULL if channel_id is invalid or no longer 102 // exists. This should be checked with ChannelOwner::IsValid(). 103 ChannelOwner GetChannel(int32_t channel_id); 104 void GetAllChannels(std::vector<ChannelOwner>* channels); 105 106 void DestroyChannel(int32_t channel_id); 107 void DestroyAllChannels(); 108 109 size_t NumOfChannels() const; 110 111 private: 112 uint32_t instance_id_; 113 114 Atomic32 last_channel_id_; 115 116 rtc::CriticalSection lock_; 117 std::vector<ChannelOwner> channels_; 118 119 // For generation of random ssrc:s. 120 webrtc::Random random_; 121 122 RTC_DISALLOW_COPY_AND_ASSIGN(ChannelManager); 123 }; 124 } // namespace voe 125 } // namespace webrtc 126 127 #endif // VOICE_ENGINE_CHANNEL_MANAGER_H_ 128