mirror/Sunshine
1
0
Fork 0
mirror of https://github.com/LizardByte/Sunshine.git synced 2025-03-27 05:37:16 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

Fixed bug causing the video playback to freeze

Browse Source
This commit is contained in:
loki 2019-12-08 21:16:02 +01:00
parent 10cd1c0f2b
commit eb57c35ffc
4 changed files with 47 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
sunshine/queue.h
View File

@ -36,6 +36,12 @@ public:
_cv.notify_all();
}
bool peek() {
std::lock_guard lg { _lock };
return !_queue.empty();
}
status_t pop() {
std::unique_lock ul{_lock};

33
sunshine/stream.cpp
View File

@ -173,7 +173,7 @@ public:
std::vector<char> full_payload;
auto old_msg = std::move(_queue_packet);
TUPLE_2D(_, old_packet, std::move(_queue_packet));
TUPLE_2D_REF(_, old_packet, old_msg);
std::string_view new_payload { (char*)packet->data, packet->dataLength };
@ -225,12 +225,12 @@ private:
host_t _host;
};
class server_t {
class control_server_t {
public:
server_t(server_t &&) noexcept = default;
server_t &operator=(server_t &&) noexcept = default;
control_server_t(control_server_t &&) noexcept = default;
control_server_t &operator=(control_server_t &&) noexcept = default;
explicit server_t(std::uint16_t port) : _host { host_create(_addr, port) } {}
explicit control_server_t(std::uint16_t port) : _host { host_create(_addr, port) } {}
template<class T, class X>
void iterate(std::chrono::duration<T, X> timeout) {
@ -271,7 +271,7 @@ public:
}
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;
std::unordered_map<std::uint16_t, std::function<void(const std::string_view&)>> _map_type_cb;
ENetAddress _addr;
host_t _host;
};
@ -478,12 +478,12 @@ void rtsp_server_t::map(const std::string_view& cmd, std::function<void(host_t&,
_map_cmd_cb.emplace(cmd, std::move(cb));
}
void server_t::map(uint16_t type, std::function<void(const std::string_view &)> cb) {
void control_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 };
void controlThread(video::event_queue_t idr_events) {
control_server_t server { CONTROL_PORT };
auto input = platf::input();
server.map(packetTypes[IDX_START_A], [](const std::string_view &payload) {
@ -516,7 +516,7 @@ void controlThread() {
std::cout << "---end stats---" << std::endl;
});
server.map(packetTypes[IDX_INVALIDATE_REF_FRAMES], [](const std::string_view &payload) {
server.map(packetTypes[IDX_INVALIDATE_REF_FRAMES], [idr_events](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;
@ -528,7 +528,7 @@ void controlThread() {
std::cout << "firstFrame [" << firstFrame << ']' << std::endl;
std::cout << "lastFrame [" << lastFrame << ']' << std::endl;
exit(100);
idr_events->push(std::make_pair(firstFrame, lastFrame));
});
server.map(packetTypes[IDX_INPUT_DATA], [&input](const std::string_view &payload) mutable {
@ -639,7 +639,7 @@ void audioThread() {
captureThread.join();
}
void videoThread() {
void videoThread(video::event_queue_t idr_events) {
auto &config = session.config;
int lowseq = 0;
@ -652,9 +652,9 @@ void videoThread() {
return;
}
std::shared_ptr<safe::queue_t<video::packet_t>> packets{new safe::queue_t<video::packet_t>};
video::packet_queue_t packets{new safe::queue_t<video::packet_t>};
std::thread captureThread{video::capture_display, packets, config.monitor};
std::thread captureThread{video::capture_display, packets, idr_events, config.monitor};
frame_queue_t packet_queue;
uint16_t frame{1};
@ -955,9 +955,10 @@ void cmd_announce(host_t &host, peer_t peer, msg_t &&req) {
session.pingTimeout = std::chrono::steady_clock::now() + config::stream.ping_timeout;
session.client_state = 1;
video::event_queue_t idr_events { new video::event_queue_t::element_type };
session.audioThread = std::thread {audioThread};
session.videoThread = std::thread {videoThread};
session.controlThread = std::thread {controlThread};
session.videoThread = std::thread {videoThread, idr_events};
session.controlThread = std::thread {controlThread, idr_events};
respond(host, peer, &option, 200, "OK", req->sequenceNumber, {});
}

30
sunshine/video.cpp
View File

@ -31,10 +31,10 @@ void free_packet(AVPacket *packet) {
av_packet_free(&packet);
}
using ctx_t = util::safe_ptr<AVCodecContext, free_ctx>;
using frame_t = util::safe_ptr<AVFrame, free_frame>;
using sws_t = util::safe_ptr<SwsContext, sws_freeContext>;
using ctx_t = util::safe_ptr<AVCodecContext, free_ctx>;
using frame_t = util::safe_ptr<AVFrame, free_frame>;
using sws_t = util::safe_ptr<SwsContext, sws_freeContext>;
using img_queue_t = std::shared_ptr<safe::queue_t<platf::img_t>>;
auto open_codec(ctx_t &ctx, AVCodec *codec, AVDictionary **options) {
avcodec_open2(ctx.get(), codec, options);
@ -44,7 +44,7 @@ auto open_codec(ctx_t &ctx, AVCodec *codec, AVDictionary **options) {
});
}
void encode(int64_t frame, ctx_t &ctx, sws_t &sws, frame_t &yuv_frame, platf::img_t &img, std::shared_ptr<safe::queue_t<packet_t>> &packets) {
void encode(int64_t frame, ctx_t &ctx, sws_t &sws, frame_t &yuv_frame, platf::img_t &img, packet_queue_t &packets) {
av_frame_make_writable(yuv_frame.get());
const int linesizes[2] {
@ -83,8 +83,10 @@ void encode(int64_t frame, ctx_t &ctx, sws_t &sws, frame_t &yuv_frame, platf::im
}
void encodeThread(
std::shared_ptr<safe::queue_t<platf::img_t>> images,
std::shared_ptr<safe::queue_t<packet_t>> packets, config_t config) {
img_queue_t images,
packet_queue_t packets,
event_queue_t idr_events,
config_t config) {
int framerate = config.framerate;
auto codec = avcodec_find_encoder(AV_CODEC_ID_H264);
@ -140,18 +142,26 @@ void encodeThread(
}
while (auto img = images->pop()) {
if(idr_events->peek()) {
yuv_frame->pict_type = AV_PICTURE_TYPE_I;
frame = idr_events->pop()->first;
}
encode(frame++, ctx, sws, yuv_frame, img, packets);
yuv_frame->pict_type = AV_PICTURE_TYPE_NONE;
}
packets->stop();
}
void capture_display(std::shared_ptr<safe::queue_t<packet_t>> packets, config_t config) {
void capture_display(packet_queue_t packets, event_queue_t idr_events, config_t config) {
int framerate = config.framerate;
std::shared_ptr<safe::queue_t<platf::img_t>> images { new safe::queue_t<platf::img_t> };
img_queue_t images { new safe::queue_t<platf::img_t> };
std::thread encoderThread { &encodeThread, images, packets, config };
std::thread encoderThread { &encodeThread, images, packets, idr_events, config };
auto disp = platf::display();

6
sunshine/video.h
View File

@ -11,7 +11,9 @@ struct AVPacket;
namespace video {
void free_packet(AVPacket *packet);
using packet_t = util::safe_ptr<AVPacket, free_packet>;
using packet_t = util::safe_ptr<AVPacket, free_packet>;
using packet_queue_t = std::shared_ptr<safe::queue_t<packet_t>>;
using event_queue_t = std::shared_ptr<safe::queue_t<std::pair<int64_t, int64_t>>>;
struct config_t {
int width;
@ -21,7 +23,7 @@ struct config_t {
int slicesPerFrame;
};
void capture_display(std::shared_ptr<safe::queue_t<packet_t>> packets, config_t config);
void capture_display(packet_queue_t packets, event_queue_t idr_events, config_t config);
}
#endif //SUNSHINE_VIDEO_H