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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright 2021 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_BROWSER_CONTROL_PLAYBACK_COMMAND_DISPATCHER_H_
#define COMPONENTS_CAST_STREAMING_BROWSER_CONTROL_PLAYBACK_COMMAND_DISPATCHER_H_
#include <memory>
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "base/task/sequenced_task_runner.h"
#include "components/cast_streaming/browser/common/streaming_initialization_info.h"
#include "components/cast_streaming/browser/control/remoting/remoting_session_client.h"
#include "components/cast_streaming/browser/control/remoting/renderer_rpc_call_translator.h"
#include "components/cast_streaming/browser/control/remoting/rpc_demuxer_stream_handler.h"
#include "components/cast_streaming/browser/control/remoting/rpc_initialization_call_handler_base.h"
#include "components/cast_streaming/browser/control/renderer_control_multiplexer.h"
#include "components/cast_streaming/browser/public/receiver_config.h"
#include "components/cast_streaming/common/public/mojom/renderer_controller.mojom.h"
#include "media/base/audio_decoder_config.h"
#include "media/base/video_decoder_config.h"
#include "media/mojo/mojom/renderer.mojom.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "third_party/openscreen/src/cast/streaming/public/receiver_session.h"
#include "third_party/openscreen/src/cast/streaming/public/rpc_messenger.h"
namespace openscreen {
namespace cast {
class RpcMessage;
} // namespace cast
} // namespace openscreen
namespace cast_streaming {
namespace remoting {
class RendererRpcCallTranslator;
} // namespace remoting
// This class is responsible for initiating a mojo connection to a
// media::Renderer (expected to be a PlaybackCommandForwardingRenderer) via an
// initial call to |control_configuration| and then setting up any necessary
// infrastructure for messages to be passed across this pipe. While this class
// is used to initiate and maintain control over a Renderer for a Cast Remoting
// session, it is also used for starting playback of a Cast Mirroring session.
class PlaybackCommandDispatcher
: public remoting::RpcInitializationCallHandlerBase,
public remoting::RemotingSessionClient,
public remoting::RpcDemuxerStreamHandler::Client {
public:
// Creates a new PlaybackCommandDispatcher.
// |flush_until_cb| will be called when a Flush() remoting command is
// received, if remoting is enabled.
// |remoting_constraints| will be validated against received config values for
// configs received when configuring the remoting stream, if remoting is
// enabled.
PlaybackCommandDispatcher(
scoped_refptr<base::SequencedTaskRunner> task_runner,
mojo::AssociatedRemote<mojom::RendererController> control_configuration,
remoting::RendererRpcCallTranslator::FlushUntilCallback flush_until_cb,
std::optional<ReceiverConfig::RemotingConstraints> remoting_constraints);
~PlaybackCommandDispatcher() override;
void RegisterCommandSource(
mojo::PendingReceiver<media::mojom::Renderer> controls);
// Call Flush() on the Renderer associated with this streaming session.
void Flush(media::mojom::Renderer::FlushCallback callback);
// Begins playback of the streaming session via calls to the Renderer if it
// has not yet begun. This is required because the remote device will
// sometimes, but not always, call StartPlayingFrom() on a session that it
// wants to be playing.
void TryStartPlayback(base::TimeDelta timestamp);
// remoting::RemotingSessionClient overrides.
void OnRemotingSessionNegotiated(
openscreen::cast::RpcMessenger* messenger) override;
void ConfigureRemotingAsync(
Dispatcher* dispatcher,
const openscreen::cast::ReceiverSession* session,
openscreen::cast::ReceiverSession::ConfiguredReceivers receivers)
override;
void OnRemotingSessionEnded() override;
private:
void SendRemotingRpcMessageToRemote(
openscreen::cast::RpcMessenger::Handle handle,
std::unique_ptr<openscreen::cast::RpcMessage> message);
void ProcessRemotingRpcMessageFromRemote(
std::unique_ptr<openscreen::cast::RpcMessage> message);
// Acquires a new handle from |messenger_|.
openscreen::cast::RpcMessenger::Handle AcquireHandle();
// Registers a |handle| with |messenger_| to receive callbacks to
// ProcessRemotingRpcMessageFromRemote().
void RegisterHandleForCallbacks(
openscreen::cast::RpcMessenger::Handle handle);
// Starts streaming if each expected audio or video config has been received.
void MaybeStartStreamingSession();
// Callback for mojom::RendererController::SetPlaybackController() call.
void OnSetPlaybackControllerDone();
// RpcInitializationCallHandlerBase overrides.
void RpcAcquireRendererAsync(
openscreen::cast::RpcMessenger::Handle remote_handle,
AcquireRendererCB cb) override;
void OnRpcAcquireDemuxer(
openscreen::cast::RpcMessenger::Handle audio_stream_handle,
openscreen::cast::RpcMessenger::Handle video_stream_handle) override;
// RpcDemuxerStreamHandler::Client overrides.
void OnNewAudioConfig(media::AudioDecoderConfig new_config) override;
void OnNewVideoConfig(media::VideoDecoderConfig new_config) override;
// Synchronization for calling |acquire_renderer_cb_| at the correct time.
bool has_set_playback_controller_call_returned_ = false;
base::OnceCallback<void()> acquire_renderer_cb_;
raw_ptr<openscreen::cast::RpcMessenger> messenger_;
// Multiplexes Renderer commands from a number of senders.
std::unique_ptr<RendererControlMultiplexer> muxer_;
// Handles translating between Remoting commands (in proto form) and mojo
// commands.
std::unique_ptr<remoting::RendererRpcCallTranslator>
renderer_call_translator_;
// Handles DemuxerStream interactions.
std::unique_ptr<remoting::RpcDemuxerStreamHandler> demuxer_stream_handler_;
// Handles for the demuxer stream data providers, to be used for dispatching
// demuxer stream RPC commands.
std::optional<StreamingInitializationInfo> streaming_init_info_;
std::optional<ReceiverConfig::RemotingConstraints> remoting_constraints_;
raw_ptr<Dispatcher> streaming_dispatcher_ = nullptr;
raw_ptr<const openscreen::cast::ReceiverSession> receiver_session_ = nullptr;
// The mojo API used to configure the renderer controls in the renderer
// process. Although this instance is only needed once, it is stored as an
// instance variable so that the destruction of this instance is visible to
// the Renderer process via the mojo disconnection handler.
mojo::AssociatedRemote<mojom::RendererController> control_configuration_;
scoped_refptr<base::SequencedTaskRunner> task_runner_;
base::WeakPtrFactory<PlaybackCommandDispatcher> weak_factory_{this};
};
} // namespace cast_streaming
#endif // COMPONENTS_CAST_STREAMING_BROWSER_CONTROL_PLAYBACK_COMMAND_DISPATCHER_H_
|
