| // Copyright 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef CHROME_RENDERER_MEDIA_CAST_SESSION_H_ |
| #define CHROME_RENDERER_MEDIA_CAST_SESSION_H_ |
| |
| #include <memory> |
| #include <vector> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "base/memory/ref_counted.h" |
| #include "media/cast/cast_config.h" |
| #include "net/base/ip_endpoint.h" |
| |
| namespace base { |
| class DictionaryValue; |
| class SingleThreadTaskRunner; |
| class Value; |
| } // namespace base |
| |
| namespace media { |
| namespace cast { |
| class AudioFrameInput; |
| class VideoFrameInput; |
| } // namespace cast |
| } // namespace media |
| |
| class CastSessionDelegate; |
| |
| // This class represents a Cast session and allows the session to be |
| // configured on the main thread. Actual work is forwarded to |
| // CastSessionDelegate on the IO thread. |
| class CastSession : public base::RefCounted<CastSession> { |
| public: |
| using AudioFrameInputAvailableCallback = |
| base::Callback<void(const scoped_refptr<media::cast::AudioFrameInput>&)>; |
| using VideoFrameInputAvailableCallback = |
| base::Callback<void(const scoped_refptr<media::cast::VideoFrameInput>&)>; |
| using SendPacketCallback = base::Callback<void(const std::vector<char>&)>; |
| using EventLogsCallback = base::Callback<void(std::unique_ptr<base::Value>)>; |
| using StatsCallback = |
| base::Callback<void(std::unique_ptr<base::DictionaryValue>)>; |
| using ErrorCallback = base::Callback<void(const std::string&)>; |
| |
| explicit CastSession(scoped_refptr<base::SingleThreadTaskRunner> task_runner); |
| |
| // Start encoding of audio and video using the provided configuration. |
| // |
| // When Cast sender is started and ready to be used |
| // media::cast::FrameInput will be given through |callback|. |
| // If it encounters an error, |error_callback| will be invoked with the |
| // error message. Both |callback| and |error_callback| will be made on |
| // the main thread. |
| // |StartUDP()| must be called before these methods. |
| void StartAudio(const media::cast::FrameSenderConfig& config, |
| const AudioFrameInputAvailableCallback& callback, |
| const ErrorCallback& error_callback); |
| void StartVideo(const media::cast::FrameSenderConfig& config, |
| const VideoFrameInputAvailableCallback& callback, |
| const ErrorCallback& error_callback); |
| |
| // Start remoting a stream. |error_callback| will be invoked when any error |
| // occurs. |StartUDP()| must be called before calling this method. |
| void StartRemotingStream(int32_t stream_id, |
| const media::cast::FrameSenderConfig& config, |
| const ErrorCallback& error_callback); |
| |
| // This will create the Cast transport and connect to |remote_endpoint|. |
| // |options| is a dictionary which contain optional configuration for the |
| // udp transport. |
| // Must be called before initialization of audio or video. |
| void StartUDP(const net::IPEndPoint& remote_endpoint, |
| std::unique_ptr<base::DictionaryValue> options, |
| const ErrorCallback& error_callback); |
| |
| // Creates or destroys event subscriber for the audio or video stream. |
| // |is_audio|: true if the event subscriber is for audio. Video otherwise. |
| // |enable|: If true, creates an event subscriber. Otherwise destroys |
| // existing subscriber and discards logs. |
| void ToggleLogging(bool is_audio, bool enable); |
| |
| // Returns raw event logs in serialized format for either the audio or video |
| // stream since last call and returns result in |callback|. Also attaches |
| // |extra_data| to the log. |
| void GetEventLogsAndReset(bool is_audio, |
| const std::string& extra_data, const EventLogsCallback& callback); |
| |
| // Returns stats in a DictionaryValue format for either the audio or video |
| // stream since last call and returns result in |callback|. |
| void GetStatsAndReset(bool is_audio, const StatsCallback& callback); |
| |
| private: |
| friend class base::RefCounted<CastSession>; |
| virtual ~CastSession(); |
| |
| // This member should never be dereferenced on the main thread. |
| // CastSessionDelegate lives only on the IO thread. It is always |
| // safe to post task on the IO thread to access CastSessionDelegate |
| // because it is owned by this object. |
| std::unique_ptr<CastSessionDelegate> delegate_; |
| |
| // A main thread task runner that might execute JavaScript. |
| const scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_; |
| |
| // Proxy to the IO task runner. |
| const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_; |
| |
| DISALLOW_COPY_AND_ASSIGN(CastSession); |
| }; |
| |
| #endif // CHROME_RENDERER_MEDIA_CAST_SESSION_H_ |