blob: c22f3271c609814841c692c20dfc452f51935943 (
plain)
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
|
// Copyright 2021 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.
#include "cast/standalone_receiver/simple_remoting_receiver.h"
#include <utility>
#include "cast/streaming/message_fields.h"
#include "cast/streaming/remoting.pb.h"
namespace openscreen {
namespace cast {
namespace {
VideoCodec ParseProtoCodec(VideoDecoderConfig::Codec value) {
switch (value) {
case VideoDecoderConfig_Codec_kCodecHEVC:
return VideoCodec::kHevc;
case VideoDecoderConfig_Codec_kCodecH264:
return VideoCodec::kH264;
case VideoDecoderConfig_Codec_kCodecVP8:
return VideoCodec::kVp8;
case VideoDecoderConfig_Codec_kCodecVP9:
return VideoCodec::kVp9;
case VideoDecoderConfig_Codec_kCodecAV1:
return VideoCodec::kAv1;
default:
return VideoCodec::kNotSpecified;
}
}
AudioCodec ParseProtoCodec(AudioDecoderConfig::Codec value) {
switch (value) {
case AudioDecoderConfig_Codec_kCodecAAC:
return AudioCodec::kAac;
case AudioDecoderConfig_Codec_kCodecOpus:
return AudioCodec::kOpus;
default:
return AudioCodec::kNotSpecified;
}
}
} // namespace
SimpleRemotingReceiver::SimpleRemotingReceiver(RpcMessenger* messenger)
: messenger_(messenger) {
messenger_->RegisterMessageReceiverCallback(
RpcMessenger::kFirstHandle, [this](std::unique_ptr<RpcMessage> message) {
this->OnInitializeCallbackMessage(std::move(message));
});
}
SimpleRemotingReceiver::~SimpleRemotingReceiver() {
messenger_->UnregisterMessageReceiverCallback(RpcMessenger::kFirstHandle);
}
void SimpleRemotingReceiver::SendInitializeMessage(
SimpleRemotingReceiver::InitializeCallback initialize_cb) {
initialize_cb_ = std::move(initialize_cb);
OSP_DVLOG
<< "Indicating to the sender we are ready for remoting initialization.";
openscreen::cast::RpcMessage rpc;
rpc.set_handle(RpcMessenger::kAcquireRendererHandle);
rpc.set_proc(openscreen::cast::RpcMessage::RPC_DS_INITIALIZE);
// The initialize message contains the handle to be used for sending the
// initialization callback message.
rpc.set_integer_value(RpcMessenger::kFirstHandle);
messenger_->SendMessageToRemote(rpc);
}
void SimpleRemotingReceiver::SendPlaybackRateMessage(double playback_rate) {
openscreen::cast::RpcMessage rpc;
rpc.set_handle(RpcMessenger::kAcquireRendererHandle);
rpc.set_proc(openscreen::cast::RpcMessage::RPC_R_SETPLAYBACKRATE);
rpc.set_double_value(playback_rate);
messenger_->SendMessageToRemote(rpc);
}
void SimpleRemotingReceiver::OnInitializeCallbackMessage(
std::unique_ptr<RpcMessage> message) {
OSP_DCHECK(message->proc() == RpcMessage::RPC_DS_INITIALIZE_CALLBACK);
if (!initialize_cb_) {
OSP_DLOG_INFO << "Received an initialization callback message but no "
"callback was set.";
return;
}
const DemuxerStreamInitializeCallback& callback_message =
message->demuxerstream_initializecb_rpc();
const auto audio_codec =
callback_message.has_audio_decoder_config()
? ParseProtoCodec(callback_message.audio_decoder_config().codec())
: AudioCodec::kNotSpecified;
const auto video_codec =
callback_message.has_video_decoder_config()
? ParseProtoCodec(callback_message.video_decoder_config().codec())
: VideoCodec::kNotSpecified;
OSP_DLOG_INFO << "Initializing remoting with audio codec "
<< CodecToString(audio_codec) << " and video codec "
<< CodecToString(video_codec);
initialize_cb_(audio_codec, video_codec);
initialize_cb_ = nullptr;
}
} // namespace cast
} // namespace openscreen
|
