Skip to content

Bring PS5 GTA6 to 120FPS with DLSS 5. An advanced Windows video player and capture enhancement tool featuring real-time preview for videos, images, and capture card sources. Combine AI-powered Super Resolution, DLSS5 image enhancement, and Frame Generation to deliver a next-generation visual experience.

C++
7.7 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-only
#include "veyra/remoteplay/VideoIngress.h"
#include <algorithm>
#include <limits>
#include <stdexcept>
namespace veyra::remoteplay {
void QueueLimits::validate() const {
    if(maxFrames<1||maxFrames>64||maxBytes<1024||maxBytes>64u*1024u*1024u ||
       maxConfigBytes<1||maxConfigBytes>maxBytes||maxConfigBytes>1024u*1024u ||
       maxAge100ns<10000||maxAge100ns>5000000)
        throw std::invalid_argument("Unsafe remote-play queue limits");
}
VideoIngress::VideoIngress(QueueLimits limits):limits_(limits){limits_.validate();}
void VideoIngress::begin(Generation g) {
    if(!g)throw std::invalid_argument("Generation zero is invalid");
    std::lock_guard lock(mutex_);queue_.clear();config_.reset();generation_=g;payloadBytes_=0;
    closed_=false;waiting_=true;pendingIdr_=false;lastIdr_=-1;sequence_.reset();stats_={};cv_.notify_all();
}
void VideoIngress::recoverLocked() {
    stats_.dropped+=queue_.size();queue_.clear();payloadBytes_=0;
    // Only one epoch increment per recovery episode; repeated P frames do not reset forever.
    if(!waiting_){++stats_.epoch;++stats_.recoveries;}
    waiting_=true;pendingIdr_=true;updateStatsLocked();
}
void VideoIngress::updateStatsLocked() {
    stats_.depth=queue_.size();stats_.bytes=payloadBytes_+(config_?config_->payload.size():0);
    stats_.waitingForIdr=waiting_;
    stats_.highWaterDepth=std::max(stats_.highWaterDepth,stats_.depth);
    stats_.highWaterBytes=std::max(stats_.highWaterBytes,stats_.bytes);
}
bool VideoIngress::expiredLocked(HostTime now) const {
    return !queue_.empty() && (now<queue_.front().sample.arrival100ns ||
        now-queue_.front().sample.arrival100ns>limits_.maxAge100ns);
}
PushStatus VideoIngress::push(VideoSample sample,HostTime now) {
    std::lock_guard lock(mutex_);
    if(closed_)return PushStatus::Closed;
    if(sample.generation!=generation_)return PushStatus::WrongGeneration;
    if(sample.payload.size()==0 || sample.arrival100ns<0 || now<sample.arrival100ns ||
       !sample.payload.paddingIsZero() || sample.framesLost<0 ||
       !((sample.width==1280&&sample.height==720)||(sample.width==1920&&sample.height==1080))){
        ++stats_.rejected;recoverLocked();return PushStatus::Malformed;
    }
    const auto nal=inspectAnnexB(sample.payload.bytes(),sample.codec);
    if(!nal.valid){++stats_.rejected;recoverLocked();return PushStatus::Malformed;}
    if(sample.kind==SampleKind::CodecConfig){
        if(!nal.hasConfig||nal.hasPicture||sample.wireFrameIndex||sample.payload.size()>limits_.maxConfigBytes){
            ++stats_.rejected;recoverLocked();return PushStatus::Malformed;
        }
        ++stats_.configMessages;
        const bool same=config_&&config_->codec==sample.codec&&config_->width==sample.width&&config_->height==sample.height&&
            std::ranges::equal(config_->payload.bytes(),sample.payload.bytes());
        if(!same){recoverLocked();config_=std::make_shared<const VideoSample>(std::move(sample));}
        updateStatsLocked();return PushStatus::ConfigStored;
    }
    if(sample.kind!=SampleKind::AccessUnit || !nal.hasPicture){++stats_.rejected;recoverLocked();return PushStatus::Malformed;}
    ++stats_.accessUnits;
    if(sample.wireFrameIndex){
        const auto seq=sequence_.observe(*sample.wireFrameIndex);
        if(!seq.accepted){++stats_.rejected;return PushStatus::Malformed;}
        if(seq.gap)recoverLocked();
    }
    if(sample.framesLost>0 || sample.referenceRecovered)recoverLocked();
    if(now-sample.arrival100ns>limits_.maxAge100ns){++stats_.dropped;recoverLocked();return PushStatus::WaitingForIdr;}
    if(!config_ || sample.codec!=config_->codec || sample.width!=config_->width || sample.height!=config_->height){
        ++stats_.dropped;recoverLocked();return PushStatus::WaitingForIdr;
    }
    const auto headerBytes=config_->payload.size();
    if(sample.payload.size()>limits_.maxBytes-headerBytes){++stats_.dropped;recoverLocked();return PushStatus::WaitingForIdr;}
    if(expiredLocked(now)||queue_.size()>=limits_.maxFrames||payloadBytes_>limits_.maxBytes-headerBytes-sample.payload.size())recoverLocked();
    if(waiting_&&!nal.idr){++stats_.dropped;pendingIdr_=true;return PushStatus::WaitingForIdr;}
    const bool reset=waiting_;
    queue_.push_back(QueuedVideo{std::move(sample),reset?config_:nullptr,stats_.epoch,reset});
    payloadBytes_+=queue_.back().sample.payload.size();waiting_=false;
    if(reset)pendingIdr_=false;
    ++stats_.accepted;updateStatsLocked();cv_.notify_one();return PushStatus::Accepted;
}
std::optional<QueuedVideo> VideoIngress::tryPop(HostTime now) {
    std::lock_guard lock(mutex_);
    if(closed_)return {};
    if(expiredLocked(now)){recoverLocked();return {};}
    if(queue_.empty())return {};
    auto out=std::move(queue_.front());queue_.pop_front();payloadBytes_-=out.sample.payload.size();
    ++stats_.consumed;updateStatsLocked();return out;
}
bool VideoIngress::waitForData(std::chrono::milliseconds timeout) {
    std::unique_lock lock(mutex_);cv_.wait_for(lock,timeout,[&]{return closed_||!queue_.empty();});return !closed_&&!queue_.empty();
}
bool VideoIngress::takeIdrRequest(HostTime now) {
    std::lock_guard lock(mutex_);
    if(closed_||!pendingIdr_||now<0||(lastIdr_>=0&&(now<lastIdr_||now-lastIdr_<5000000)))return false;
    lastIdr_=now;pendingIdr_=false;++stats_.idrRequests;return true;
}
void VideoIngress::requireKeyframe(){std::lock_guard lock(mutex_);if(!closed_)recoverLocked();}
void VideoIngress::close(){std::lock_guard lock(mutex_);closed_=true;queue_.clear();config_.reset();payloadBytes_=0;pendingIdr_=false;updateStatsLocked();cv_.notify_all();}
VideoQueueStats VideoIngress::stats()const{std::lock_guard lock(mutex_);return stats_;}

AudioIngress::AudioIngress(std::uint32_t maxMs):maxMs_(maxMs){if(maxMs<10||maxMs>200)throw std::invalid_argument("Audio buffer must be 10..200 ms");}
void AudioIngress::begin(Generation g){
    if(!g)throw std::invalid_argument("Generation zero is invalid");
    std::lock_guard lock(mutex_);generation_=g;rate_=channels_=0;frames_=0;nextSample_=0;closed_=false;gap_=true;queue_.clear();stats_={};
}
bool AudioIngress::push(PcmBlock block){
    std::lock_guard lock(mutex_);
    if(closed_||block.generation!=generation_)return false;
    if(!block.valid()||block.arrival100ns<0||block.firstSample>std::numeric_limits<std::uint64_t>::max()-block.frames()){
        ++stats_.rejected;return false;
    }
    const auto budget=static_cast<std::size_t>(block.rate)*maxMs_/1000u;
    if(block.frames()>budget){++stats_.rejected;gap_=true;return false;}
    if(rate_!=block.rate||channels_!=block.channels){stats_.dropped+=queue_.size();queue_.clear();frames_=0;rate_=block.rate;channels_=block.channels;nextSample_=block.firstSample;gap_=true;}
    if(block.firstSample<nextSample_){++stats_.rejected;return false;}
    if(block.firstSample!=nextSample_)gap_=true;
    while(!queue_.empty()&&frames_+block.frames()>budget){frames_-=queue_.front().frames();queue_.pop_front();++stats_.dropped;gap_=true;}
    if(gap_&&!queue_.empty())queue_.front().discontinuity=true;
    block.discontinuity|=gap_;gap_=false;nextSample_=block.firstSample+block.frames();frames_+=block.frames();
    queue_.push_back(std::move(block));++stats_.accepted;stats_.bufferedMs=1000.0*static_cast<double>(frames_)/rate_;return true;
}
std::optional<PcmBlock> AudioIngress::tryPop(){
    std::lock_guard lock(mutex_);if(closed_||queue_.empty())return {};
    auto out=std::move(queue_.front());queue_.pop_front();frames_-=out.frames();++stats_.consumed;
    stats_.bufferedMs=rate_?1000.0*static_cast<double>(frames_)/rate_:0;return out;
}
void AudioIngress::close(){std::lock_guard lock(mutex_);closed_=true;queue_.clear();frames_=0;stats_.bufferedMs=0;}
AudioQueueStats AudioIngress::stats()const{std::lock_guard lock(mutex_);return stats_;}
} // namespace veyra::remoteplay