diff options
Diffstat (limited to 'chromium/third_party/webrtc/call/call.h')
| -rw-r--r-- | chromium/third_party/webrtc/call/call.h | 47 |
1 files changed, 46 insertions, 1 deletions
diff --git a/chromium/third_party/webrtc/call/call.h b/chromium/third_party/webrtc/call/call.h index 77cd3d26901..af9111826ce 100644 --- a/chromium/third_party/webrtc/call/call.h +++ b/chromium/third_party/webrtc/call/call.h @@ -15,6 +15,7 @@ #include <string> #include <vector> +#include "api/adaptation/resource.h" #include "api/media_types.h" #include "call/audio_receive_stream.h" #include "call/audio_send_stream.h" @@ -28,9 +29,46 @@ #include "rtc_base/copy_on_write_buffer.h" #include "rtc_base/network/sent_packet.h" #include "rtc_base/network_route.h" +#include "rtc_base/ref_count.h" namespace webrtc { +// A restricted way to share the module process thread across multiple instances +// of Call that are constructed on the same worker thread (which is what the +// peer connection factory guarantees). +// SharedModuleThread supports a callback that is issued when only one reference +// remains, which is used to indicate to the original owner that the thread may +// be discarded. +class SharedModuleThread : public rtc::RefCountInterface { + protected: + SharedModuleThread(std::unique_ptr<ProcessThread> process_thread, + std::function<void()> on_one_ref_remaining); + friend class rtc::scoped_refptr<SharedModuleThread>; + ~SharedModuleThread() override; + + public: + // Instantiates a default implementation of ProcessThread. + static rtc::scoped_refptr<SharedModuleThread> Create( + const char* name, + std::function<void()> on_one_ref_remaining); + + // Allows injection of an externally created process thread. + static rtc::scoped_refptr<SharedModuleThread> Create( + std::unique_ptr<ProcessThread> process_thread, + std::function<void()> on_one_ref_remaining); + + void EnsureStarted(); + + ProcessThread* process_thread(); + + private: + void AddRef() const override; + rtc::RefCountReleaseStatus Release() const override; + + class Impl; + mutable std::unique_ptr<Impl> impl_; +}; + // A Call instance can contain several send and/or receive streams. All streams // are assumed to have the same remote endpoint and will share bitrate estimates // etc. @@ -50,8 +88,10 @@ class Call { static Call* Create(const Call::Config& config); static Call* Create(const Call::Config& config, + rtc::scoped_refptr<SharedModuleThread> call_thread); + static Call* Create(const Call::Config& config, Clock* clock, - std::unique_ptr<ProcessThread> call_thread, + rtc::scoped_refptr<SharedModuleThread> call_thread, std::unique_ptr<ProcessThread> pacer_thread); virtual AudioSendStream* CreateAudioSendStream( @@ -86,6 +126,11 @@ class Call { virtual void DestroyFlexfecReceiveStream( FlexfecReceiveStream* receive_stream) = 0; + // When a resource is overused, the Call will try to reduce the load on the + // sysem, for example by reducing the resolution or frame rate of encoded + // streams. + virtual void AddAdaptationResource(rtc::scoped_refptr<Resource> resource) = 0; + // All received RTP and RTCP packets for the call should be inserted to this // PacketReceiver. The PacketReceiver pointer is valid as long as the // Call instance exists. |