| /* |
| * Copyright 2017 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #ifndef API_ORTC_ORTCFACTORYINTERFACE_H_ |
| #define API_ORTC_ORTCFACTORYINTERFACE_H_ |
| |
| #include <memory> |
| #include <string> |
| #include <utility> // For std::move. |
| |
| #include "api/mediaconstraintsinterface.h" |
| #include "api/mediastreaminterface.h" |
| #include "api/mediatypes.h" |
| #include "api/ortc/ortcrtpreceiverinterface.h" |
| #include "api/ortc/ortcrtpsenderinterface.h" |
| #include "api/ortc/packettransportinterface.h" |
| #include "api/ortc/rtptransportcontrollerinterface.h" |
| #include "api/ortc/rtptransportinterface.h" |
| #include "api/ortc/srtptransportinterface.h" |
| #include "api/ortc/udptransportinterface.h" |
| #include "api/rtcerror.h" |
| #include "api/rtpparameters.h" |
| #include "rtc_base/network.h" |
| #include "rtc_base/scoped_ref_ptr.h" |
| #include "rtc_base/thread.h" |
| |
| namespace webrtc { |
| |
| // TODO(deadbeef): This should be part of /api/, but currently it's not and |
| // including its header violates checkdeps rules. |
| class AudioDeviceModule; |
| |
| // WARNING: This is experimental/under development, so use at your own risk; no |
| // guarantee about API stability is guaranteed here yet. |
| // |
| // This class is the ORTC analog of PeerConnectionFactory. It acts as a factory |
| // for ORTC objects that can be connected to each other. |
| // |
| // Some of these objects may not be represented by the ORTC specification, but |
| // follow the same general principles. |
| // |
| // If one of the factory methods takes another object as an argument, it MUST |
| // have been created by the same OrtcFactory. |
| // |
| // On object lifetimes: objects should be destroyed in this order: |
| // 1. Objects created by the factory. |
| // 2. The factory itself. |
| // 3. Objects passed into OrtcFactoryInterface::Create. |
| class OrtcFactoryInterface { |
| public: |
| // |network_thread| is the thread on which packets are sent and received. |
| // If null, a new rtc::Thread with a default socket server is created. |
| // |
| // |signaling_thread| is used for callbacks to the consumer of the API. If |
| // null, the current thread will be used, which assumes that the API consumer |
| // is running a message loop on this thread (either using an existing |
| // rtc::Thread, or by calling rtc::Thread::Current()->ProcessMessages). |
| // |
| // |network_manager| is used to determine which network interfaces are |
| // available. This is used for ICE, for example. If null, a default |
| // implementation will be used. Only accessed on |network_thread|. |
| // |
| // |socket_factory| is used (on the network thread) for creating sockets. If |
| // it's null, a default implementation will be used, which assumes |
| // |network_thread| is a normal rtc::Thread. |
| // |
| // |adm| is optional, and allows a different audio device implementation to |
| // be injected; otherwise a platform-specific module will be used that will |
| // use the default audio input. |
| // |
| // |audio_encoder_factory| and |audio_decoder_factory| are used to |
| // instantiate audio codecs; they determine what codecs are supported. |
| // |
| // Note that the OrtcFactoryInterface does not take ownership of any of the |
| // objects passed in by raw pointer, and as previously stated, these objects |
| // can't be destroyed before the factory is. |
| static RTCErrorOr<std::unique_ptr<OrtcFactoryInterface>> Create( |
| rtc::Thread* network_thread, |
| rtc::Thread* signaling_thread, |
| rtc::NetworkManager* network_manager, |
| rtc::PacketSocketFactory* socket_factory, |
| AudioDeviceModule* adm, |
| rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory); |
| |
| // Constructor for convenience which uses default implementations where |
| // possible (though does still require that the current thread runs a message |
| // loop; see above). |
| static RTCErrorOr<std::unique_ptr<OrtcFactoryInterface>> Create( |
| rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory) { |
| return Create(nullptr, nullptr, nullptr, nullptr, nullptr, |
| audio_encoder_factory, audio_decoder_factory); |
| } |
| |
| virtual ~OrtcFactoryInterface() {} |
| |
| // Creates an RTP transport controller, which is used in calls to |
| // CreateRtpTransport methods. If your application has some notion of a |
| // "call", you should create one transport controller per call. |
| // |
| // However, if you only are using one RtpTransport object, this doesn't need |
| // to be called explicitly; CreateRtpTransport will create one automatically |
| // if |rtp_transport_controller| is null. See below. |
| // |
| // TODO(deadbeef): Add MediaConfig and RtcEventLog arguments? |
| virtual RTCErrorOr<std::unique_ptr<RtpTransportControllerInterface>> |
| CreateRtpTransportController() = 0; |
| |
| // Creates an RTP transport using the provided packet transports and |
| // transport controller. |
| // |
| // |rtp| will be used for sending RTP packets, and |rtcp| for RTCP packets. |
| // |
| // |rtp| can't be null. |rtcp| must be non-null if and only if |
| // |rtp_parameters.rtcp.mux| is false, indicating that RTCP muxing isn't used. |
| // Note that if RTCP muxing isn't enabled initially, it can still enabled |
| // later through SetParameters. |
| // |
| // If |transport_controller| is null, one will automatically be created, and |
| // its lifetime managed by the returned RtpTransport. This should only be |
| // done if a single RtpTransport is being used to communicate with the remote |
| // endpoint. |
| virtual RTCErrorOr<std::unique_ptr<RtpTransportInterface>> CreateRtpTransport( |
| const RtpTransportParameters& rtp_parameters, |
| PacketTransportInterface* rtp, |
| PacketTransportInterface* rtcp, |
| RtpTransportControllerInterface* transport_controller) = 0; |
| |
| // Creates an SrtpTransport which is an RTP transport that uses SRTP. |
| virtual RTCErrorOr<std::unique_ptr<SrtpTransportInterface>> |
| CreateSrtpTransport( |
| const RtpTransportParameters& rtp_parameters, |
| PacketTransportInterface* rtp, |
| PacketTransportInterface* rtcp, |
| RtpTransportControllerInterface* transport_controller) = 0; |
| |
| // Returns the capabilities of an RTP sender of type |kind|. These |
| // capabilities can be used to determine what RtpParameters to use to create |
| // an RtpSender. |
| // |
| // If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure. |
| virtual RtpCapabilities GetRtpSenderCapabilities( |
| cricket::MediaType kind) const = 0; |
| |
| // Creates an RTP sender with |track|. Will not start sending until Send is |
| // called. This is provided as a convenience; it's equivalent to calling |
| // CreateRtpSender with a kind (see below), followed by SetTrack. |
| // |
| // |track| and |transport| must not be null. |
| virtual RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>> CreateRtpSender( |
| rtc::scoped_refptr<MediaStreamTrackInterface> track, |
| RtpTransportInterface* transport) = 0; |
| |
| // Overload of CreateRtpSender allows creating the sender without a track. |
| // |
| // |kind| must be MEDIA_TYPE_AUDIO or MEDIA_TYPE_VIDEO. |
| virtual RTCErrorOr<std::unique_ptr<OrtcRtpSenderInterface>> CreateRtpSender( |
| cricket::MediaType kind, |
| RtpTransportInterface* transport) = 0; |
| |
| // Returns the capabilities of an RTP receiver of type |kind|. These |
| // capabilities can be used to determine what RtpParameters to use to create |
| // an RtpReceiver. |
| // |
| // If for some reason you pass in MEDIA_TYPE_DATA, returns an empty structure. |
| virtual RtpCapabilities GetRtpReceiverCapabilities( |
| cricket::MediaType kind) const = 0; |
| |
| // Creates an RTP receiver of type |kind|. Will not start receiving media |
| // until Receive is called. |
| // |
| // |kind| must be MEDIA_TYPE_AUDIO or MEDIA_TYPE_VIDEO. |
| // |
| // |transport| must not be null. |
| virtual RTCErrorOr<std::unique_ptr<OrtcRtpReceiverInterface>> |
| CreateRtpReceiver(cricket::MediaType kind, |
| RtpTransportInterface* transport) = 0; |
| |
| // Create a UDP transport with IP address family |family|, using a port |
| // within the specified range. |
| // |
| // |family| must be AF_INET or AF_INET6. |
| // |
| // |min_port|/|max_port| values of 0 indicate no range restriction. |
| // |
| // Returns an error if the transport wasn't successfully created. |
| virtual RTCErrorOr<std::unique_ptr<UdpTransportInterface>> |
| CreateUdpTransport(int family, uint16_t min_port, uint16_t max_port) = 0; |
| |
| // Method for convenience that has no port range restrictions. |
| RTCErrorOr<std::unique_ptr<UdpTransportInterface>> CreateUdpTransport( |
| int family) { |
| return CreateUdpTransport(family, 0, 0); |
| } |
| |
| // NOTE: The methods below to create tracks/sources return scoped_refptrs |
| // rather than unique_ptrs, because these interfaces are also used with |
| // PeerConnection, where everything is ref-counted. |
| |
| // Creates a audio source representing the default microphone input. |
| // |options| decides audio processing settings. |
| virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource( |
| const cricket::AudioOptions& options) = 0; |
| |
| // Version of the above method that uses default options. |
| rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource() { |
| return CreateAudioSource(cricket::AudioOptions()); |
| } |
| |
| // Creates a new local video track wrapping |source|. The same |source| can |
| // be used in several tracks. |
| virtual rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack( |
| const std::string& id, |
| VideoTrackSourceInterface* source) = 0; |
| |
| // Creates an new local audio track wrapping |source|. |
| virtual rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack( |
| const std::string& id, |
| AudioSourceInterface* source) = 0; |
| }; |
| |
| } // namespace webrtc |
| |
| #endif // API_ORTC_ORTCFACTORYINTERFACE_H_ |