1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_CAST_STREAMING_TEST_CAST_STREAMING_TEST_SENDER_H_
#define COMPONENTS_CAST_STREAMING_TEST_CAST_STREAMING_TEST_SENDER_H_
#include <optional>
#include <vector>
#include "components/cast/message_port/message_port.h"
#include "components/openscreen_platform/task_runner.h"
#include "media/base/audio_decoder_config.h"
#include "media/base/decoder_buffer.h"
#include "media/base/video_decoder_config.h"
#include "net/base/ip_address.h"
#include "third_party/openscreen/src/cast/streaming/public/sender_session.h"
namespace cast_streaming {
class CastMessagePortSenderImpl;
// Cast Streaming Sender implementation for testing. This class provides basic
// functionality for starting a Cast Streaming Sender and sending audio and
// video frames to a Cast Streaming Receiver. Example usage:
//
// std::unique_ptr<cast_api_bindings::MessagePort> sender_message_port;
// std::unique_ptr<cast_api_bindings::MessagePort> receiver_message_port;
// cast_api_bindings::CreatePlatformMessagePortPair(&sender_message_port,
// &receiver_message_port);
//
// CastStreamingTestSender sender;
// sender.Start(
// std::move(sender_message_port), net::IPAddress::IPv6Localhost(),
// audio_config, video_config);
// if(!sender.RunUntilActive()) {
// return;
// }
// sender.SendAudioBuffer(audio_buffer);
// sender.SendVideoBuffer(video_buffer);
// sender.Stop();
// sender.RunUntilStopped();
//
// // Send |receiver_message_port| to a Receiver and start it.
class CastStreamingTestSender final
: public openscreen::cast::SenderSession::Client {
public:
CastStreamingTestSender();
~CastStreamingTestSender() override;
CastStreamingTestSender(const CastStreamingTestSender&) = delete;
CastStreamingTestSender& operator=(const CastStreamingTestSender&) = delete;
// Uses |message_port| as the Sender-end of a Cast Streaming MessagePort to
// instantiate a Cast Streaming Session with a Cast Streaming Receiver at
// |receiver_address|. At least one of |audio_config| or |video_config| must
// be set.
void Start(std::unique_ptr<cast_api_bindings::MessagePort> message_port,
net::IPAddress receiver_address,
std::optional<media::AudioDecoderConfig> audio_config,
std::optional<media::VideoDecoderConfig> video_config);
// Ends the Cast Streaming Session.
void Stop();
// Sends |audio_buffer| or |video_buffer| to the Receiver. These can only be
// called when |has_startup_completed_| is true.
void SendAudioBuffer(scoped_refptr<media::DecoderBuffer> audio_buffer);
void SendVideoBuffer(scoped_refptr<media::DecoderBuffer> video_buffer);
// After a call to Start(), will run until the Cast Streaming
// Sender Session is active or has failed. After this call,
// |has_startup_completed_| will be true. If the session started successfully,
// at least one of audio_decoder_config() or video_decoder_config() will be
// set, and method will return true. Otherwise returns false.
[[nodiscard]] bool RunUntilActive();
// Runs until |has_startup_completed_| is false.
void RunUntilStopped();
const std::optional<media::AudioDecoderConfig>& audio_decoder_config() const {
return audio_decoder_config_;
}
const std::optional<media::VideoDecoderConfig>& video_decoder_config() const {
return video_decoder_config_;
}
private:
class SenderObserver;
void OnCastChannelClosed();
// After a system sender message is received, negotiates Cast Streaming Sender
// Session with given audio and video configs.
void OnSystemSenderMessageReceived();
// openscreen::cast::SenderSession::Client implementation.
void OnNegotiated(const openscreen::cast::SenderSession* session,
openscreen::cast::SenderSession::ConfiguredSenders senders,
openscreen::cast::capture_recommendations::Recommendations
capture_recommendations) final;
void OnError(const openscreen::cast::SenderSession* session,
const openscreen::Error& error) final;
openscreen_platform::TaskRunner task_runner_;
openscreen::cast::Environment environment_;
std::unique_ptr<CastMessagePortSenderImpl> message_port_;
std::unique_ptr<openscreen::cast::SenderSession> sender_session_;
bool has_startup_completed_ = false;
std::optional<media::AudioDecoderConfig> audio_decoder_config_;
std::optional<media::VideoDecoderConfig> video_decoder_config_;
// Used to implement RunUntilStarted() and RunUntilStopped().
base::OnceClosure sender_started_closure_;
base::OnceClosure sender_stopped_closure_;
std::vector<openscreen::cast::AudioCaptureConfig> audio_configs_;
std::vector<openscreen::cast::VideoCaptureConfig> video_configs_;
std::unique_ptr<SenderObserver> audio_sender_observer_;
std::unique_ptr<SenderObserver> video_sender_observer_;
};
} // namespace cast_streaming
#endif // COMPONENTS_CAST_STREAMING_TEST_CAST_STREAMING_TEST_SENDER_H_
|
