mirror/Sunshine
1
0
Fork 0
mirror of https://github.com/LizardByte/Sunshine.git synced 2025-02-22 03:40:43 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Fix Empty App in Applist

Browse Source
This commit is contained in:
loki 2020-02-08 18:55:07 +01:00
parent 5cd0fd76bf
commit 834f7b9063
4 changed files with 32 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
sunshine/nvhttp.cpp
View File

@ -469,7 +469,7 @@ void serverinfo(std::shared_ptr<typename SimpleWeb::ServerBase<T>::Response> res
auto current_appid = proc::proc.running();
tree.put("root.PairStatus", pair_status);
tree.put("root.currentgame", current_appid >= 0 ? current_appid + 2 : 0);
tree.put("root.currentgame", current_appid >= 0 ? current_appid + 1 : 0);
tree.put("root.state", "_SERVER_BUSY");
std::ostringstream data;
@ -502,8 +502,6 @@ void applist(resp_https_t response, req_https_t request) {
auto &apps = tree.add_child("root", pt::ptree {});
pt::ptree desktop;
apps.put("<xmlattr>.status_code", 200);
int x = 0;
@ -516,8 +514,6 @@ void applist(resp_https_t response, req_https_t request) {
apps.push_back(std::make_pair("App", std::move(app)));
}
apps.push_back(std::make_pair("App", desktop));
}
void launch(resp_https_t response, req_https_t request) {

40
sunshine/rtsp.cpp
View File

@ -32,7 +32,7 @@ void free_msg(PRTSP_MESSAGE msg) {
class rtsp_server_t;
using msg_t = util::safe_ptr<RTSP_MESSAGE, free_msg>;
using cmd_func_t = std::function<void(rtsp_server_t *, const std::shared_ptr<session_t> &, net::peer_t, msg_t&&)>;
using cmd_func_t = std::function<void(rtsp_server_t*, net::peer_t, msg_t&&)>;
safe::event_t<launch_session_t> launch_event;
@ -90,7 +90,7 @@ public:
msg_t resp;
auto func = _map_cmd_cb.find(req->message.request.command);
if (func != std::end(_map_cmd_cb)) {
func->second(this, nullptr, peer, std::move(req));
func->second(this, peer, std::move(req));
}
else {
cmd_not_found(host(), peer, std::move(req));
@ -219,7 +219,7 @@ void cmd_not_found(net::host_t::pointer host, net::peer_t peer, msg_t&& req) {
respond(host, peer, nullptr, 404, "NOT FOUND", req->sequenceNumber, {});
}
void cmd_option(rtsp_server_t *server, const std::shared_ptr<session_t> &session, net::peer_t peer, msg_t&& req) {
void cmd_option(rtsp_server_t *server, net::peer_t peer, msg_t&& req) {
OPTION_ITEM option {};
// I know these string literals will not be modified
@ -231,7 +231,7 @@ void cmd_option(rtsp_server_t *server, const std::shared_ptr<session_t> &session
respond(server->host(), peer, &option, 200, "OK", req->sequenceNumber, {});
}
void cmd_describe(rtsp_server_t *server, const std::shared_ptr<session_t> &session, net::peer_t peer, msg_t&& req) {
void cmd_describe(rtsp_server_t *server, net::peer_t peer, msg_t&& req) {
OPTION_ITEM option {};
// I know these string literals will not be modified
@ -251,7 +251,7 @@ void cmd_describe(rtsp_server_t *server, const std::shared_ptr<session_t> &sessi
respond(server->host(), peer, &option, 200, "OK", req->sequenceNumber, payload);
}
void cmd_setup(rtsp_server_t *server, const std::shared_ptr<session_t> &session, net::peer_t peer, msg_t &&req) {
void cmd_setup(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
OPTION_ITEM options[2] {};
auto &seqn = options[0];
@ -262,13 +262,6 @@ void cmd_setup(rtsp_server_t *server, const std::shared_ptr<session_t> &session,
auto seqn_str = std::to_string(req->sequenceNumber);
seqn.content = const_cast<char*>(seqn_str.c_str());
if(session->idr_events) {
// already streaming
respond(server->host(), peer, &seqn, 503, "Service Unavailable", req->sequenceNumber, {});
return;
}
std::string_view target { req->message.request.target };
auto begin = std::find(std::begin(target), std::end(target), '=') + 1;
auto end = std::find(begin, std::end(target), '/');
@ -289,7 +282,7 @@ void cmd_setup(rtsp_server_t *server, const std::shared_ptr<session_t> &session,
respond(server->host(), peer, &seqn, 200, "OK", req->sequenceNumber, {});
}
void cmd_announce(rtsp_server_t *server, const std::shared_ptr<session_t> &session, net::peer_t peer, msg_t &&req) {
void cmd_announce(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
OPTION_ITEM option {};
// I know these string literals will not be modified
@ -298,15 +291,8 @@ void cmd_announce(rtsp_server_t *server, const std::shared_ptr<session_t> &sessi
auto seqn_str = std::to_string(req->sequenceNumber);
option.content = const_cast<char*>(seqn_str.c_str());
auto expected_state = state_e::STOPPED;
auto abort = session->state.compare_exchange_strong(expected_state, state_e::STARTING);
if(abort || !launch_event.peek()) {
//Either already streaming or /launch has not been used
if(!abort) {
session->state.store(state_e::STOPPED);
}
if(!launch_event.peek()) {
// /launch has not been used
respond(server->host(), peer, &option, 503, "Service Unavailable", req->sequenceNumber, {});
return;
@ -361,6 +347,7 @@ void cmd_announce(rtsp_server_t *server, const std::shared_ptr<session_t> &sessi
args.try_emplace("x-nv-video[0].dynamicRangeMode"sv, "0"sv);
args.try_emplace("x-nv-aqos.packetDuration"sv, "5"sv);
auto session = std::make_shared<session_t>();
try {
auto &config = session->config;
@ -393,6 +380,13 @@ void cmd_announce(rtsp_server_t *server, const std::shared_ptr<session_t> &sessi
return;
}
if(!server->accept(session)) {
BOOST_LOG(info) << "Ran out of slots for client from ["sv << ']';
respond(server->host(), peer, &option, 503, "Service Unavailable", req->sequenceNumber, {});
return;
}
auto &gcm_key = launch_session->gcm_key;
auto &iv = launch_session->iv;
@ -410,7 +404,7 @@ void cmd_announce(rtsp_server_t *server, const std::shared_ptr<session_t> &sessi
respond(server->host(), peer, &option, 200, "OK", req->sequenceNumber, {});
}
void cmd_play(rtsp_server_t *server, const std::shared_ptr<session_t> &session, net::peer_t peer, msg_t &&req) {
void cmd_play(rtsp_server_t *server, net::peer_t peer, msg_t &&req) {
OPTION_ITEM option {};
// I know these string literals will not be modified

20
sunshine/stream.cpp
View File

@ -72,8 +72,6 @@ using rh_t = util::safe_ptr<reed_solomon, reed_solomon_release>;
using video_packet_t = util::c_ptr<video_packet_raw_t>;
using audio_packet_t = util::c_ptr<audio_packet_raw_t>;
using session_queue_t = std::shared_ptr<safe::queue_t<std::pair<std::string, std::shared_ptr<session_t>>>>;
int start_broadcast(broadcast_ctx_t &ctx);
void end_broadcast(broadcast_ctx_t &ctx);
@ -92,7 +90,7 @@ public:
control_server_t(control_server_t &&) noexcept = default;
control_server_t &operator=(control_server_t &&) noexcept = default;
explicit control_server_t(std::uint16_t port) : _host { net::host_create(_addr, config::stream.channels, port) } {}
explicit control_server_t(session_queue_t session_queue, std::uint16_t port) : session_queue { session_queue }, _host { net::host_create(_addr, config::stream.channels, port) } {}
template<class T, class X>
void iterate(std::chrono::duration<T, X> timeout) {
@ -294,8 +292,8 @@ void control_server_t::send(const std::string_view & payload) {
enet_host_flush(_host.get());
}
void controlBroadcastThread(safe::event_t<bool> *shutdown_event) {
control_server_t server { CONTROL_PORT };
void controlBroadcastThread(safe::event_t<bool> *shutdown_event, session_queue_t session_queue) {
control_server_t server { session_queue, CONTROL_PORT };
server.map(packetTypes[IDX_START_A], [&](session_t *session, const std::string_view &payload) {
BOOST_LOG(debug) << "type [IDX_START_A]"sv;
@ -395,7 +393,7 @@ void recvThread(broadcast_ctx_t &ctx) {
auto &video_sock = ctx.video_sock;
auto &audio_sock = ctx.audio_sock;
auto &session_queue = ctx.session_queue;
auto &session_queue = ctx.message_queue_queue;
auto &io = ctx.io;
udp::endpoint peer;
@ -585,10 +583,12 @@ void audioBroadcastThread(safe::event_t<bool> *shutdown_event, udp::socket &sock
int start_broadcast(broadcast_ctx_t &ctx) {
ctx.video_packets = std::make_shared<video::packet_queue_t::element_type>();
ctx.audio_packets = std::make_shared<audio::packet_queue_t::element_type>();
ctx.message_queue_queue = std::make_shared<message_queue_queue_t::element_type>();
ctx.session_queue = std::make_shared<session_queue_t::element_type>();
ctx.video_thread = std::thread { videoBroadcastThread, &ctx.shutdown_event, std::ref(ctx.video_sock), ctx.video_packets };
ctx.audio_thread = std::thread { audioBroadcastThread, &ctx.shutdown_event, std::ref(ctx.audio_sock), ctx.audio_packets };
ctx.control_thread = std::thread { controlBroadcastThread, &ctx.shutdown_event };
ctx.control_thread = std::thread { controlBroadcastThread, &ctx.shutdown_event, ctx.session_queue };
ctx.recv_thread = std::thread { recvThread, std::ref(ctx) };
@ -600,7 +600,7 @@ void end_broadcast(broadcast_ctx_t &ctx) {
ctx.video_packets->stop();
ctx.audio_packets->stop();
ctx.session_queue->stop();
ctx.message_queue_queue->stop();
ctx.video_sock.cancel();
ctx.audio_sock.cancel();
@ -623,11 +623,11 @@ int recv_ping(decltype(broadcast)::ptr_t ref, socket_e type, asio::ip::address &
};
auto messages = std::make_shared<message_queue_t::element_type>();
ref->session_queue->raise(std::make_tuple(type, addr, messages));
ref->message_queue_queue->raise(std::make_tuple(type, addr, messages));
auto fg = util::fail_guard([&]() {
// remove message queue from session
ref->session_queue->raise(std::make_tuple(type, addr, nullptr));
ref->message_queue_queue->raise(std::make_tuple(type, addr, nullptr));
});
auto msg_opt = messages->pop(config::stream.ping_timeout);

7
sunshine/stream.h
View File

@ -39,8 +39,10 @@ enum class state_e : int {
RUNNING,
};
struct session_t;
using message_queue_t = std::shared_ptr<safe::queue_t<std::pair<std::uint16_t, std::string>>>;
using message_queue_queue_t = std::shared_ptr<safe::queue_t<std::tuple<socket_e, asio::ip::address, message_queue_t>>>;
using session_queue_t = std::shared_ptr<safe::queue_t<std::pair<std::string, std::shared_ptr<session_t>>>>;
struct config_t {
audio::config_t audio;
@ -57,7 +59,8 @@ struct broadcast_ctx_t {
video::packet_queue_t video_packets;
audio::packet_queue_t audio_packets;
message_queue_queue_t session_queue;
message_queue_queue_t message_queue_queue;
session_queue_t session_queue;
std::thread video_thread;
std::thread audio_thread;
@ -81,8 +84,6 @@ struct session_t {
udp::endpoint video_peer;
udp::endpoint audio_peer;
video::idr_event_t idr_events;
crypto::aes_t gcm_key;