mirror of
https://github.com/LizardByte/Sunshine.git
synced 2024-12-27 06:16:15 +00:00
865 lines
25 KiB
C++
865 lines
25 KiB
C++
//
|
|
// Created by loki on 6/5/19.
|
|
//
|
|
|
|
#include <queue>
|
|
#include <iostream>
|
|
#include <boost/asio.hpp>
|
|
#include <moonlight-common-c/enet/include/enet/enet.h>
|
|
#include <fstream>
|
|
#include <openssl/err.h>
|
|
|
|
extern "C" {
|
|
#include <libavcodec/avcodec.h>
|
|
#include <moonlight-common-c/src/Video.h>
|
|
#include <moonlight-common-c/src/Rtsp.h>
|
|
#include <rs.h>
|
|
}
|
|
|
|
#include "config.h"
|
|
#include "utility.h"
|
|
#include "stream.h"
|
|
#include "audio.h"
|
|
#include "video.h"
|
|
#include "queue.h"
|
|
#include "crypto.h"
|
|
#include "input.h"
|
|
|
|
#define IDX_START_A 0
|
|
#define IDX_REQUEST_IDR_FRAME 0
|
|
#define IDX_START_B 1
|
|
#define IDX_INVALIDATE_REF_FRAMES 2
|
|
#define IDX_LOSS_STATS 3
|
|
#define IDX_INPUT_DATA 5
|
|
#define IDX_RUMBLE_DATA 6
|
|
#define IDX_TERMINATION 7
|
|
|
|
static const short packetTypes[] = {
|
|
0x0305, // Start A
|
|
0x0307, // Start B
|
|
0x0301, // Invalidate reference frames
|
|
0x0201, // Loss Stats
|
|
0x0204, // Frame Stats (unused)
|
|
0x0206, // Input data
|
|
0x010b, // Rumble data
|
|
0x0100, // Termination
|
|
};
|
|
|
|
namespace asio = boost::asio;
|
|
namespace sys = boost::system;
|
|
|
|
using asio::ip::tcp;
|
|
using asio::ip::udp;
|
|
|
|
using namespace std::literals;
|
|
|
|
namespace stream {
|
|
|
|
constexpr auto RTSP_SETUP_PORT = 48010;
|
|
constexpr auto VIDEO_STREAM_PORT = 47998;
|
|
constexpr auto CONTROL_PORT = 47999;
|
|
constexpr auto AUDIO_STREAM_PORT = 48000;
|
|
|
|
#pragma pack(push, 1)
|
|
|
|
struct video_packet_raw_t {
|
|
uint8_t *payload() {
|
|
return (uint8_t *)(this + 1);
|
|
}
|
|
|
|
RTP_PACKET rtp;
|
|
NV_VIDEO_PACKET packet;
|
|
};
|
|
|
|
struct audio_packet_raw_t {
|
|
uint8_t *payload() {
|
|
return (uint8_t *)(this + 1);
|
|
}
|
|
|
|
RTP_PACKET rtp;
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
crypto::aes_t gcm_key;
|
|
crypto::aes_t iv;
|
|
|
|
struct config_t {
|
|
audio::config_t audio;
|
|
video::config_t monitor;
|
|
int packetsize;
|
|
|
|
bool sops;
|
|
std::optional<int> gcmap;
|
|
};
|
|
|
|
struct session_t {
|
|
config_t config;
|
|
|
|
std::thread audioThread;
|
|
std::thread videoThread;
|
|
std::thread controlThread;
|
|
|
|
std::chrono::steady_clock::time_point pingTimeout;
|
|
int client_state;
|
|
|
|
crypto::aes_t gcm_key;
|
|
crypto::aes_t iv;
|
|
} session;
|
|
|
|
void free_msg(PRTSP_MESSAGE msg) {
|
|
freeMessage(msg);
|
|
|
|
delete msg;
|
|
}
|
|
|
|
using msg_t = util::safe_ptr<RTSP_MESSAGE, free_msg>;
|
|
using packet_t = util::safe_ptr<ENetPacket, enet_packet_destroy>;
|
|
using host_t = util::safe_ptr<ENetHost, enet_host_destroy>;
|
|
using rh_t = util::safe_ptr<reed_solomon, reed_solomon_release>;
|
|
using video_packet_t = util::safe_ptr<video_packet_raw_t, util::c_free>;
|
|
using audio_packet_t = util::safe_ptr<audio_packet_raw_t, util::c_free>;
|
|
|
|
host_t host_create(ENetAddress &addr, std::uint16_t port) {
|
|
enet_address_set_host(&addr, "0.0.0.0");
|
|
enet_address_set_port(&addr, port);
|
|
|
|
return host_t { enet_host_create(PF_INET, &addr, 1, 1, 0, 0) };
|
|
}
|
|
|
|
class server_t {
|
|
public:
|
|
server_t(server_t &&) noexcept = default;
|
|
server_t &operator=(server_t &&) noexcept = default;
|
|
|
|
explicit server_t(std::uint16_t port) : _host { host_create(_addr, port) } {}
|
|
|
|
template<class T, class X>
|
|
void iterate(std::chrono::duration<T, X> timeout) {
|
|
ENetEvent event;
|
|
auto res = enet_host_service(_host.get(), &event, std::chrono::floor<std::chrono::milliseconds>(timeout).count());
|
|
|
|
if(res > 0) {
|
|
switch(event.type) {
|
|
case ENET_EVENT_TYPE_RECEIVE:
|
|
{
|
|
packet_t packet { event.packet };
|
|
|
|
std::uint16_t *type = (std::uint16_t *)packet->data;
|
|
std::string_view payload { (char*)packet->data + sizeof(*type), packet->dataLength - sizeof(*type) };
|
|
|
|
|
|
auto cb = _map_type_cb.find(*type);
|
|
if(cb == std::end(_map_type_cb)) {
|
|
std::cout << "type [Unknown] { " << util::hex(*type).to_string_view() << " }" << std::endl;
|
|
std::cout << "---data---" << std::endl << util::hex_vec(payload) << std::endl << "---end data---" << std::endl;
|
|
}
|
|
|
|
else {
|
|
cb->second(payload);
|
|
}
|
|
}
|
|
break;
|
|
case ENET_EVENT_TYPE_CONNECT:
|
|
std::cout << "CLIENT CONNECTED" << std::endl;
|
|
break;
|
|
case ENET_EVENT_TYPE_DISCONNECT:
|
|
std::cout << "CLIENT DISCONNECTED" << std::endl;
|
|
break;
|
|
case ENET_EVENT_TYPE_NONE:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
void map(uint16_t type, std::function<void(const std::string_view&)> cb);
|
|
private:
|
|
std::unordered_map<std::uint8_t, std::function<void(const std::string_view&)>> _map_type_cb;
|
|
ENetAddress _addr;
|
|
host_t _host;
|
|
};
|
|
|
|
namespace fec {
|
|
using rs_t = util::safe_ptr<reed_solomon, reed_solomon_release>;
|
|
|
|
struct fec_t {
|
|
size_t data_shards;
|
|
size_t nr_shards;
|
|
size_t percentage;
|
|
|
|
size_t blocksize;
|
|
util::buffer_t<char> shards;
|
|
|
|
std::string_view operator[](size_t el) const {
|
|
return { &shards[el*blocksize], blocksize };
|
|
}
|
|
|
|
size_t size() const {
|
|
return nr_shards;
|
|
}
|
|
};
|
|
|
|
fec_t encode(const std::string_view &payload, size_t blocksize, size_t fecpercentage) {
|
|
auto payload_size = payload.size();
|
|
|
|
auto pad = payload_size % blocksize != 0;
|
|
|
|
auto data_shards = payload_size / blocksize + (pad ? 1 : 0);
|
|
auto parity_shards = (data_shards * fecpercentage + 99) / 100;
|
|
auto nr_shards = data_shards + parity_shards;
|
|
|
|
if(nr_shards > DATA_SHARDS_MAX) {
|
|
std::cerr << "Error: number of fragments for reed solomon exceeds DATA_SHARDS_MAX"sv << std::endl;
|
|
std::cerr << nr_shards << " > "sv << DATA_SHARDS_MAX << std::endl;
|
|
exit(9);
|
|
}
|
|
|
|
util::buffer_t<char> shards { nr_shards * blocksize };
|
|
util::buffer_t<uint8_t*> shards_p { nr_shards };
|
|
|
|
// copy payload + padding
|
|
auto next = std::copy(std::begin(payload), std::end(payload), std::begin(shards));
|
|
std::fill(next, std::end(shards), 0); // padding with zero
|
|
|
|
for(auto x = 0; x < nr_shards; ++x) {
|
|
shards_p[x] = (uint8_t*)&shards[x * blocksize];
|
|
}
|
|
|
|
// packets = parity_shards + data_shards
|
|
rs_t rs { reed_solomon_new(data_shards, parity_shards) };
|
|
|
|
reed_solomon_encode(rs.get(), shards_p.begin(), nr_shards, blocksize);
|
|
|
|
return {
|
|
data_shards,
|
|
nr_shards,
|
|
fecpercentage,
|
|
blocksize,
|
|
std::move(shards)
|
|
};
|
|
}
|
|
}
|
|
|
|
template<class F>
|
|
std::vector<uint8_t> insert(uint64_t insert_size, uint64_t slice_size, const std::string_view &data, F &&f) {
|
|
auto pad = data.size() % slice_size != 0;
|
|
auto elements = data.size() / slice_size + (pad ? 1 : 0);
|
|
|
|
std::vector<uint8_t> result;
|
|
result.resize(elements * insert_size + data.size());
|
|
|
|
auto next = std::begin(data);
|
|
for(auto x = 0; x < elements - 1; ++x) {
|
|
void *p = &result[x*(insert_size + slice_size)];
|
|
|
|
f(p, x, elements);
|
|
|
|
std::copy(next, next + slice_size, (char*)p + insert_size);
|
|
next += slice_size;
|
|
}
|
|
|
|
if(pad) {
|
|
auto x = elements - 1;
|
|
void *p = &result[x*(insert_size + slice_size)];
|
|
|
|
f(p, x, elements);
|
|
|
|
std::copy(next, std::end(data), (char*)p + insert_size);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void print_msg(PRTSP_MESSAGE msg) {
|
|
std::string_view type = msg->type == TYPE_RESPONSE ? "RESPONSE"sv : "REQUEST"sv;
|
|
|
|
std::string_view payload { msg->payload, (size_t)msg->payloadLength };
|
|
std::string_view protocol { msg->protocol };
|
|
auto seqnm = msg->sequenceNumber;
|
|
std::string_view messageBuffer { msg->messageBuffer };
|
|
|
|
std::cout << "type ["sv << type << ']' << std::endl;
|
|
std::cout << "sequence number ["sv << seqnm << ']' << std::endl;
|
|
std::cout << "protocol :: "sv << protocol << std::endl;
|
|
std::cout << "payload :: "sv << payload << std::endl;
|
|
|
|
if(msg->type == TYPE_RESPONSE) {
|
|
auto &resp = msg->message.response;
|
|
|
|
auto statuscode = resp.statusCode;
|
|
std::string_view status { resp.statusString };
|
|
|
|
std::cout << "statuscode :: "sv << statuscode << std::endl;
|
|
std::cout << "status :: "sv << status << std::endl;
|
|
}
|
|
else {
|
|
auto& req = msg->message.request;
|
|
|
|
std::string_view command { req.command };
|
|
std::string_view target { req.target };
|
|
|
|
std::cout << "command :: "sv << command << std::endl;
|
|
std::cout << "target :: "sv << target << std::endl;
|
|
}
|
|
|
|
for(auto option = msg->options; option != nullptr; option = option->next) {
|
|
std::string_view content { option->content };
|
|
std::string_view name { option->option };
|
|
|
|
std::cout << name << " :: "sv << content << std::endl;
|
|
}
|
|
|
|
std::cout << "---Begin MessageBuffer---"sv << std::endl << messageBuffer << std::endl << "---End MessageBuffer---"sv << std::endl << std::endl;
|
|
}
|
|
|
|
using frame_queue_t = std::vector<video::packet_t>;
|
|
video::packet_t next_packet(uint16_t &frame, std::shared_ptr<safe::queue_t<video::packet_t>> &packets, frame_queue_t &packet_queue) {
|
|
auto packet = packets->pop();
|
|
|
|
if(!packet) {
|
|
return nullptr;
|
|
}
|
|
|
|
assert(packet->pts >= frame);
|
|
|
|
auto comp = [](const video::packet_t &l, const video::packet_t &r) {
|
|
return l->pts > r->pts;
|
|
};
|
|
|
|
if(packet->pts > frame) {
|
|
packet_queue.emplace_back(std::move(packet));
|
|
std::push_heap(std::begin(packet_queue), std::end(packet_queue), comp);
|
|
|
|
if (packet_queue.front()->pts != frame) {
|
|
return next_packet(frame, packets, packet_queue);
|
|
}
|
|
|
|
std::pop_heap(std::begin(packet_queue), std::end(packet_queue), comp);
|
|
packet = std::move(packet_queue.back());
|
|
packet_queue.pop_back();
|
|
}
|
|
|
|
++frame;
|
|
return packet;
|
|
}
|
|
|
|
std::vector<uint8_t> replace(const std::string_view &original, const std::string_view &old, const std::string_view &_new) {
|
|
std::vector<uint8_t> replaced;
|
|
|
|
auto search = [&](auto it) {
|
|
return std::search(it, std::end(original), std::begin(old), std::end(old));
|
|
};
|
|
|
|
auto begin = std::begin(original);
|
|
for(auto next = search(begin); next != std::end(original); next = search(++next)) {
|
|
std::copy(begin, next, std::back_inserter(replaced));
|
|
std::copy(std::begin(_new), std::end(_new), std::back_inserter(replaced));
|
|
|
|
next = begin = next + old.size();
|
|
}
|
|
|
|
std::copy(begin, std::end(original), std::back_inserter(replaced));
|
|
|
|
return replaced;
|
|
}
|
|
|
|
void server_t::map(uint16_t type, std::function<void(const std::string_view &)> cb) {
|
|
_map_type_cb.emplace(type, std::move(cb));
|
|
}
|
|
|
|
void controlThread() {
|
|
server_t server { CONTROL_PORT };
|
|
|
|
std::shared_ptr display = platf::display();
|
|
server.map(packetTypes[IDX_START_A], [](const std::string_view &payload) {
|
|
session.pingTimeout = std::chrono::steady_clock::now() + config::stream.ping_timeout;
|
|
|
|
std::cout << "type [IDX_START_A]"sv << std::endl;
|
|
});
|
|
|
|
server.map(packetTypes[IDX_START_B], [](const std::string_view &payload) {
|
|
session.pingTimeout = std::chrono::steady_clock::now() + config::stream.ping_timeout;
|
|
|
|
std::cout << "type [IDX_START_B]"sv << std::endl;
|
|
});
|
|
|
|
server.map(packetTypes[IDX_LOSS_STATS], [](const std::string_view &payload) {
|
|
session.pingTimeout = std::chrono::steady_clock::now() + config::stream.ping_timeout;
|
|
|
|
/* std::cout << "type [IDX_LOSS_STATS]"sv << std::endl;
|
|
|
|
int32_t *stats = (int32_t*)payload.data();
|
|
auto count = stats[0];
|
|
std::chrono::milliseconds t { stats[1] };
|
|
|
|
auto lastGoodFrame = stats[3];
|
|
|
|
std::cout << "---begin stats---" << std::endl;
|
|
std::cout << "loss count since last report [" << count << ']' << std::endl;
|
|
std::cout << "time in milli since last report [" << t.count() << ']' << std::endl;
|
|
std::cout << "last good frame [" << lastGoodFrame << ']' << std::endl;
|
|
std::cout << "---end stats---" << std::endl; */
|
|
});
|
|
|
|
server.map(packetTypes[IDX_INVALIDATE_REF_FRAMES], [](const std::string_view &payload) {
|
|
session.pingTimeout = std::chrono::steady_clock::now() + config::stream.ping_timeout;
|
|
|
|
std::cout << "type [IDX_INVALIDATE_REF_FRAMES]"sv << std::endl;
|
|
|
|
std::int64_t *frames = (std::int64_t *)payload.data();
|
|
auto firstFrame = frames[0];
|
|
auto lastFrame = frames[1];
|
|
|
|
std::cout << "firstFrame [" << firstFrame << ']' << std::endl;
|
|
std::cout << "lastFrame [" << lastFrame << ']' << std::endl;
|
|
});
|
|
|
|
server.map(packetTypes[IDX_INPUT_DATA], [display](const std::string_view &payload) mutable {
|
|
session.pingTimeout = std::chrono::steady_clock::now() + config::stream.ping_timeout;
|
|
|
|
std::cout << "type [IDX_INPUT_DATA]"sv << std::endl;
|
|
|
|
int32_t tagged_cipher_length = util::endian::big(*(int32_t*)payload.data());
|
|
std::string_view tagged_cipher { payload.data() + sizeof(tagged_cipher_length), (size_t)tagged_cipher_length };
|
|
|
|
crypto::cipher_t cipher { session.gcm_key };
|
|
cipher.padding = false;
|
|
|
|
std::vector<uint8_t> plaintext;
|
|
if(cipher.decrypt_gcm(session.iv, tagged_cipher, plaintext)) {
|
|
// something went wrong :(
|
|
|
|
std::cout << "failed to verify tag"sv << std::endl;
|
|
session.client_state = 0;
|
|
}
|
|
|
|
if(tagged_cipher_length >= 16 + session.iv.size()) {
|
|
std::copy(payload.end() - 16, payload.end(), std::begin(session.iv));
|
|
}
|
|
|
|
input::print(plaintext.data());
|
|
input::passthrough(display.get(), plaintext.data());
|
|
});
|
|
|
|
while(session.client_state > 0) {
|
|
if(std::chrono::steady_clock::now() > session.pingTimeout) {
|
|
session.client_state = 0;
|
|
}
|
|
|
|
server.iterate(2s);
|
|
}
|
|
}
|
|
|
|
std::optional<udp::endpoint> recv_peer(udp::socket &sock) {
|
|
std::array<char, 2048> buf;
|
|
|
|
char ping[] = {
|
|
0x50, 0x49, 0x4E, 0x47
|
|
};
|
|
|
|
udp::endpoint peer;
|
|
while (session.client_state > 0) {
|
|
asio::deadline_timer timer { sock.get_executor() };
|
|
timer.expires_from_now(boost::posix_time::seconds(2));
|
|
timer.async_wait([&](sys::error_code c){
|
|
sock.cancel();
|
|
});
|
|
|
|
sys::error_code ping_error;
|
|
auto len = sock.receive_from(asio::buffer(buf), peer, 0, ping_error);
|
|
if(ping_error == sys::errc::make_error_code(sys::errc::operation_canceled)) {
|
|
return {};
|
|
}
|
|
|
|
timer.cancel();
|
|
|
|
if (len == 4 && !std::memcmp(ping, buf.data(), sizeof(ping))) {
|
|
std::cout << "PING from ["sv << peer.address().to_string() << ':' << peer.port() << ']' << std::endl;
|
|
|
|
return std::make_optional(std::move(peer));;
|
|
}
|
|
|
|
std::cout << "Unknown transmission: "sv << util::hex_vec(std::string_view{buf.data(), len}) << std::endl;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
void audioThread() {
|
|
auto &config = session.config;
|
|
|
|
asio::io_service io;
|
|
udp::socket sock{io, udp::endpoint(udp::v6(), AUDIO_STREAM_PORT)};
|
|
|
|
auto peer = recv_peer(sock);
|
|
if(!peer) {
|
|
return;
|
|
}
|
|
|
|
std::shared_ptr<safe::queue_t<audio::packet_t>> packets{new safe::queue_t<audio::packet_t>};
|
|
|
|
std::thread captureThread{audio::capture, packets, config.audio};
|
|
|
|
uint16_t frame{1};
|
|
|
|
while (auto packet = packets->pop()) {
|
|
if(session.client_state == 0) {
|
|
packets->stop();
|
|
|
|
break;
|
|
}
|
|
|
|
audio_packet_t audio_packet { (audio_packet_raw_t*)malloc(sizeof(audio_packet_raw_t) + packet->size()) };
|
|
|
|
audio_packet->rtp.sequenceNumber = util::endian::big(frame++);
|
|
audio_packet->rtp.packetType = 97;
|
|
std::copy(std::begin(*packet), std::end(*packet), audio_packet->payload());
|
|
|
|
sock.send_to(asio::buffer((char*)audio_packet.get(), sizeof(audio_packet_raw_t) + packet->size()), *peer);
|
|
// std::cout << "Audio ["sv << frame << "] :: send..."sv << std::endl;
|
|
}
|
|
|
|
captureThread.join();
|
|
}
|
|
|
|
void videoThread() {
|
|
auto &config = session.config;
|
|
|
|
int lowseq = 0;
|
|
|
|
asio::io_service io;
|
|
udp::socket sock{io, udp::endpoint(udp::v6(), VIDEO_STREAM_PORT)};
|
|
|
|
auto peer = recv_peer(sock);
|
|
if(!peer) {
|
|
return;
|
|
}
|
|
|
|
std::shared_ptr<safe::queue_t<video::packet_t>> packets{new safe::queue_t<video::packet_t>};
|
|
|
|
std::thread captureThread{video::capture_display, packets, config.monitor};
|
|
|
|
frame_queue_t packet_queue;
|
|
uint16_t frame{1};
|
|
|
|
while (auto packet = next_packet(frame, packets, packet_queue)) {
|
|
if(session.client_state == 0) {
|
|
packets->stop();
|
|
|
|
break;
|
|
}
|
|
|
|
std::string_view payload{(char *) packet->data, (size_t) packet->size};
|
|
std::vector<uint8_t> payload_new;
|
|
|
|
auto nv_packet_header = "\0017charss"sv;
|
|
std::copy(std::begin(nv_packet_header), std::end(nv_packet_header), std::back_inserter(payload_new));
|
|
std::copy(std::begin(payload), std::end(payload), std::back_inserter(payload_new));
|
|
|
|
payload = {(char *) payload_new.data(), payload_new.size()};
|
|
|
|
// make sure moonlight recognizes the nalu code for IDR frames
|
|
if (packet->flags & AV_PKT_FLAG_KEY) {
|
|
//TODO: Not all encoders encode their IDR frames with `"\000\000\001e"`
|
|
auto seq_i_frame_old = "\000\000\001e"sv;
|
|
auto seq_i_frame = "\000\000\000\001e"sv;
|
|
|
|
assert(std::search(std::begin(payload), std::end(payload), std::begin(seq_i_frame), std::end(seq_i_frame)) ==
|
|
std::end(payload));
|
|
payload_new = replace(payload, seq_i_frame_old, seq_i_frame);
|
|
|
|
payload = {(char *) payload_new.data(), payload_new.size()};
|
|
}
|
|
|
|
// insert packet headers
|
|
auto blocksize = config.packetsize + MAX_RTP_HEADER_SIZE;
|
|
auto payload_blocksize = blocksize - sizeof(video_packet_raw_t);
|
|
|
|
auto fecpercentage { 25 };
|
|
|
|
payload_new = insert(sizeof(video_packet_raw_t), payload_blocksize,
|
|
payload, [&](void *p, int fecIndex, int end) {
|
|
video_packet_raw_t *video_packet = (video_packet_raw_t *)p;
|
|
|
|
video_packet->packet.flags = FLAG_CONTAINS_PIC_DATA;
|
|
video_packet->packet.frameIndex = packet->pts;
|
|
video_packet->packet.streamPacketIndex = ((uint32_t)lowseq + fecIndex) << 8;
|
|
video_packet->packet.fecInfo = (
|
|
fecIndex << 12 |
|
|
end << 22 |
|
|
fecpercentage << 4
|
|
);
|
|
|
|
if(fecIndex == 0) {
|
|
video_packet->packet.flags |= FLAG_SOF;
|
|
}
|
|
|
|
if(fecIndex == end - 1) {
|
|
video_packet->packet.flags |= FLAG_EOF;
|
|
}
|
|
|
|
video_packet->rtp.sequenceNumber = util::endian::big<uint16_t>(lowseq + fecIndex);
|
|
});
|
|
|
|
payload = {(char *) payload_new.data(), payload_new.size()};
|
|
|
|
auto shards = fec::encode(payload, blocksize, 25);
|
|
|
|
for (auto x = shards.data_shards; x < shards.size(); ++x) {
|
|
video_packet_raw_t *inspect = (video_packet_raw_t *)shards[x].data();
|
|
|
|
inspect->packet.flags = FLAG_CONTAINS_PIC_DATA;
|
|
inspect->packet.streamPacketIndex = ((uint32_t)(lowseq + x)) << 8;
|
|
inspect->packet.frameIndex = packet->pts;
|
|
inspect->packet.fecInfo = (
|
|
x << 12 |
|
|
shards.data_shards << 22 |
|
|
fecpercentage << 4
|
|
);
|
|
|
|
inspect->rtp.sequenceNumber = util::endian::big<uint16_t>(lowseq + x);
|
|
}
|
|
|
|
for (auto x = 0; x < shards.size(); ++x) {
|
|
sock.send_to(asio::buffer(shards[x]), *peer);
|
|
}
|
|
|
|
// std::cout << "Frame ["sv << packet->pts << "] :: send ["sv << shards.size() << "] shards..."sv << std::endl;
|
|
lowseq += shards.size();
|
|
|
|
}
|
|
|
|
captureThread.join();
|
|
}
|
|
|
|
void respond(tcp::socket &sock, POPTION_ITEM options, int statuscode, const char *status_msg, int seqn, const std::string_view &payload) {
|
|
RTSP_MESSAGE resp {};
|
|
|
|
auto g = util::fail_guard([&]() {
|
|
freeMessage(&resp);
|
|
});
|
|
|
|
createRtspResponse(&resp, nullptr, 0, const_cast<char*>("RTSP/1.0"), statuscode, const_cast<char*>(status_msg), seqn, options, const_cast<char*>(payload.data()), (int)payload.size());
|
|
|
|
int serialized_len;
|
|
util::c_ptr<char> raw_resp { serializeRtspMessage(&resp, &serialized_len) };
|
|
|
|
std::string_view tmp_resp { raw_resp.get(), (size_t)serialized_len };
|
|
std::cout << "---Begin Response---" << std::endl << tmp_resp << "---End Response---" << std::endl << std::endl;
|
|
|
|
asio::write(sock, asio::buffer(tmp_resp));
|
|
}
|
|
|
|
void cmd_not_found(tcp::socket &&sock, msg_t&& req) {
|
|
respond(sock, nullptr, 404, "NOT FOUND", req->sequenceNumber, {});
|
|
}
|
|
|
|
void cmd_option(tcp::socket &&sock, msg_t&& req) {
|
|
OPTION_ITEM option {};
|
|
|
|
// I know these string literals will not be modified
|
|
option.option = const_cast<char*>("CSeq");
|
|
|
|
auto seqn_str = std::to_string(req->sequenceNumber);
|
|
option.content = const_cast<char*>(seqn_str.c_str());
|
|
|
|
respond(sock, &option, 200, "OK", req->sequenceNumber, {});
|
|
}
|
|
|
|
void cmd_describe(tcp::socket &&sock, msg_t&& req) {
|
|
OPTION_ITEM option {};
|
|
|
|
// I know these string literals will not be modified
|
|
option.option = const_cast<char*>("CSeq");
|
|
|
|
auto seqn_str = std::to_string(req->sequenceNumber);
|
|
option.content = const_cast<char*>(seqn_str.c_str());
|
|
|
|
// FIXME: Moonlight will accept the payload, but the value of the option is not correct
|
|
respond(sock, &option, 200, "OK", req->sequenceNumber, "surround-params=NONE"sv);
|
|
}
|
|
|
|
void cmd_setup(tcp::socket &&sock, msg_t &&req) {
|
|
OPTION_ITEM options[2] {};
|
|
|
|
auto &seqn = options[0];
|
|
auto &session_option = options[1];
|
|
|
|
seqn.option = const_cast<char*>("CSeq");
|
|
|
|
auto seqn_str = std::to_string(req->sequenceNumber);
|
|
seqn.content = const_cast<char*>(seqn_str.c_str());
|
|
|
|
if(session.client_state >= 0) {
|
|
// already streaming
|
|
|
|
respond(sock, &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), '/');
|
|
std::string_view type { begin, (size_t)std::distance(begin, end) };
|
|
|
|
if(type == "audio"sv) {
|
|
seqn.next = &session_option;
|
|
|
|
session_option.option = const_cast<char*>("Session");
|
|
session_option.content = const_cast<char*>("DEADBEEFCAFE;timeout = 90");
|
|
}
|
|
else if(type != "video"sv && type != "control"sv) {
|
|
cmd_not_found(std::move(sock), std::move(req));
|
|
|
|
return;
|
|
}
|
|
|
|
respond(sock, &seqn, 200, "OK", req->sequenceNumber, {});
|
|
}
|
|
|
|
void cmd_announce(tcp::socket &&sock, msg_t &&req) {
|
|
OPTION_ITEM option {};
|
|
|
|
// I know these string literals will not be modified
|
|
option.option = const_cast<char*>("CSeq");
|
|
|
|
auto seqn_str = std::to_string(req->sequenceNumber);
|
|
option.content = const_cast<char*>(seqn_str.c_str());
|
|
|
|
if(session.client_state >= 0) {
|
|
// already streaming
|
|
|
|
respond(sock, &option, 503, "Service Unavailable", req->sequenceNumber, {});
|
|
return;
|
|
}
|
|
|
|
std::string_view payload { req->payload, (size_t)req->payloadLength };
|
|
std::vector<std::string_view> lines;
|
|
|
|
auto whitespace = [](char ch) {
|
|
return ch == '\n' || ch == '\r';
|
|
};
|
|
|
|
{
|
|
auto pos = std::begin(payload);
|
|
auto begin = pos;
|
|
while (pos != std::end(payload)) {
|
|
if (whitespace(*pos++)) {
|
|
lines.emplace_back(begin, pos - begin - 1);
|
|
|
|
while(whitespace(*pos)) { ++pos; }
|
|
begin = pos;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string_view client;
|
|
std::unordered_map<std::string_view, std::string_view> args;
|
|
|
|
for(auto line : lines) {
|
|
auto type = line.substr(0, 2);
|
|
if(type == "s="sv) {
|
|
client = line.substr(2);
|
|
}
|
|
else if(type == "a=") {
|
|
auto pos = line.find(':');
|
|
|
|
auto name = line.substr(2, pos - 2);
|
|
auto val = line.substr(pos + 1);
|
|
|
|
if(val[val.size() -1] == ' ') {
|
|
val = val.substr(0, val.size() -1);
|
|
}
|
|
args.emplace(name, val);
|
|
}
|
|
}
|
|
|
|
auto &config = session.config;
|
|
config.monitor.height = util::from_view(args.at("x-nv-video[0].clientViewportHt"sv));
|
|
config.monitor.width = util::from_view(args.at("x-nv-video[0].clientViewportWd"sv));
|
|
config.monitor.framerate = util::from_view(args.at("x-nv-video[0].maxFPS"sv));
|
|
config.monitor.bitrate = util::from_view(args.at("x-nv-video[0].initialBitrateKbps"sv));
|
|
config.monitor.slicesPerFrame = util::from_view(args.at("x-nv-video[0].videoEncoderSlicesPerFrame"sv));
|
|
|
|
config.audio.channels = util::from_view(args.at("x-nv-audio.surround.numChannels"sv));
|
|
config.audio.mask = util::from_view(args.at("x-nv-audio.surround.channelMask"sv));
|
|
config.audio.packetDuration = util::from_view(args.at("x-nv-aqos.packetDuration"sv));
|
|
|
|
config.packetsize = util::from_view(args.at("x-nv-video[0].packetSize"sv));
|
|
|
|
std::copy(std::begin(gcm_key), std::end(gcm_key), std::begin(session.gcm_key));
|
|
std::copy(std::begin(iv), std::end(iv), std::begin(session.iv));
|
|
|
|
session.pingTimeout = std::chrono::steady_clock::now() + config::stream.ping_timeout;
|
|
session.client_state = 1;
|
|
|
|
session.audioThread = std::thread {audioThread};
|
|
session.videoThread = std::thread {videoThread};
|
|
session.controlThread = std::thread {controlThread};
|
|
|
|
respond(sock, &option, 200, "OK", req->sequenceNumber, {});
|
|
}
|
|
|
|
void cmd_play(tcp::socket &&sock, msg_t &&req) {
|
|
OPTION_ITEM option {};
|
|
|
|
// I know these string literals will not be modified
|
|
option.option = const_cast<char*>("CSeq");
|
|
|
|
auto seqn_str = std::to_string(req->sequenceNumber);
|
|
option.content = const_cast<char*>(seqn_str.c_str());
|
|
|
|
respond(sock, &option, 200, "OK", req->sequenceNumber, {});
|
|
}
|
|
|
|
void rtpThread() {
|
|
session.client_state = -1;
|
|
|
|
asio::io_service io;
|
|
|
|
tcp::acceptor acceptor { io, tcp::endpoint { tcp::v6(), RTSP_SETUP_PORT } };
|
|
|
|
std::unordered_map<std::string_view, std::function<void(tcp::socket &&, msg_t &&)>> map_cmd_func;
|
|
map_cmd_func.emplace("OPTIONS"sv, &cmd_option);
|
|
map_cmd_func.emplace("DESCRIBE"sv, &cmd_describe);
|
|
map_cmd_func.emplace("SETUP"sv, &cmd_setup);
|
|
map_cmd_func.emplace("ANNOUNCE"sv, &cmd_announce);
|
|
|
|
map_cmd_func.emplace("PLAY"sv, &cmd_play);
|
|
|
|
while(true) {
|
|
tcp::socket sock { io };
|
|
|
|
acceptor.accept(sock);
|
|
sock.set_option(tcp::no_delay(true));
|
|
|
|
std::array<char, 2048> buf;
|
|
|
|
auto len = sock.read_some(asio::buffer(buf));
|
|
buf[std::min(buf.size(), len)] = '\0';
|
|
|
|
msg_t req { new RTSP_MESSAGE {} };
|
|
|
|
parseRtspMessage(req.get(), buf.data(), len);
|
|
|
|
print_msg(req.get());
|
|
|
|
auto func = map_cmd_func.find(req->message.request.command);
|
|
if(func == std::end(map_cmd_func)) {
|
|
cmd_not_found(std::move(sock), std::move(req));
|
|
}
|
|
else {
|
|
func->second(std::move(sock), std::move(req));
|
|
}
|
|
|
|
if(session.client_state == 0) {
|
|
session.audioThread.join();
|
|
session.videoThread.join();
|
|
session.controlThread.join();
|
|
|
|
session.client_state = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|