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.3 KB
Raw Blame
#include "AssSubtitleRenderer.h"

#include "veyra/Log.h"

#include <algorithm>
#include <chrono>
#include <cstdarg>
#include <cstdio>
#include <format>
#include <string>
#include <vector>

extern "C" {
#include <ass/ass.h>
}

namespace veyra::ui {
namespace {
// libass is chatty at verbose levels; keep errors/warnings, rate limited.
void onMessage(int level,const char* format,va_list args,void*){
    if(level>2)return;
    static auto nextLog=std::chrono::steady_clock::time_point{};
    static int suppressed=0;
    const auto now=std::chrono::steady_clock::now();
    if(now<nextLog){++suppressed;return;}
    nextLog=now+std::chrono::milliseconds(500);
    char text[512]{};
    std::vsnprintf(text,sizeof(text),format,args);
    log::warn("libass",std::format("level={} {}{}",level,text,suppressed?std::format(" (+{} suppressed)",suppressed):std::string{}));
    suppressed=0;
}
} // namespace

struct AssSubtitleRenderer::Impl {
    ASS_Library* library=nullptr;
    ASS_Renderer* renderer=nullptr;
    ASS_Track* track=nullptr;
    std::shared_ptr<const engine::SubtitleAssData> data;
    std::wstring source;
    std::string header;
    size_t fedEvents=0,fontsAdded=0;
    bool fontsReady=false;
    ASS_Image* images=nullptr;
    int frameW=0,frameH=0,storageW=0,storageH=0;
    double fontScale=1.0;

    Impl(){
        library=ass_library_init();
        if(!library){log::error("libass","ass_library_init failed");return;}
        ass_set_message_cb(library,onMessage,nullptr);
        ass_set_extract_fonts(library,1); // [Fonts] sections embedded in the script
        renderer=ass_renderer_init(library);
        if(!renderer)log::error("libass","ass_renderer_init failed");
    }
    ~Impl(){
        images=nullptr;
        if(track)ass_free_track(track);
        if(renderer)ass_renderer_done(renderer);
        if(library)ass_library_done(library);
    }
    void addFonts(const engine::SubtitleAssData& script){
        bool added=false;
        for(;fontsAdded<script.fonts.size();++fontsAdded){
            const auto& font=script.fonts[fontsAdded];
            if(font.data.empty()||font.data.size()>size_t(INT32_MAX))continue;
            ass_add_font(library,font.name.c_str(),font.data.data(),int(font.data.size()));
            added=true;
        }
        // Memory fonts reach a renderer at its next ass_set_fonts call. The
        // system provider (DirectWrite, GDI fallback) resolves everything else.
        if(added||!fontsReady){
            const auto start=std::chrono::steady_clock::now();
            ass_set_fonts(renderer,nullptr,"Microsoft YaHei",ASS_FONTPROVIDER_AUTODETECT,nullptr,1);
            log::info("libass",std::format("fonts configured container={} ms={:.1f}",fontsAdded,
                std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now()-start).count()));
            fontsReady=true;
        }
    }
    void feed(const engine::SubtitleAssData& script){
        for(;fedEvents<script.events.size();++fedEvents){
            const auto& event=script.events[fedEvents];
            if(event.chunk.empty()||event.chunk.size()>size_t(INT32_MAX))continue;
            ass_process_chunk(track,event.chunk.data(),int(event.chunk.size()),event.startMs,event.durationMs);
        }
    }
    void rebuild(const engine::SubtitleAssData& script){
        images=nullptr;
        if(track){ass_free_track(track);track=nullptr;}
        fedEvents=0;fontsAdded=0;
        addFonts(script);
        if(!script.script.empty()){
            std::vector<char> copy(script.script.begin(),script.script.end()); // ass_read_memory parses in place
            track=ass_read_memory(library,copy.data(),copy.size(),nullptr);
        }else{
            track=ass_new_track(library);
            if(track&&!script.header.empty())ass_process_codec_private(track,script.header.data(),int(script.header.size()));
        }
        if(!track){log::error("libass",std::format("track creation failed source={}",std::string(script.source.begin(),script.source.end())));return;}
        source=script.source;header=script.header;
        if(script.script.empty())feed(script);
        log::info("libass",std::format("track ready events={} styles={} playRes={}x{} fonts={}",
            track->n_events,track->n_styles,track->PlayResX,track->PlayResY,fontsAdded));
    }
};

AssSubtitleRenderer::AssSubtitleRenderer():p_(std::make_unique<Impl>()){}
AssSubtitleRenderer::~AssSubtitleRenderer()=default;

bool AssSubtitleRenderer::prepare(const std::shared_ptr<const engine::SubtitleAssData>& data){
    auto& p=*p_;
    if(!p.library||!p.renderer||!data)return false;
    if(data==p.data)return p.track!=nullptr;
    const bool grownEmbedded=p.track&&data->script.empty()&&data->source==p.source&&data->header==p.header&&
        data->events.size()>=p.fedEvents&&data->fonts.size()>=p.fontsAdded;
    if(grownEmbedded){p.addFonts(*data);p.feed(*data);}
    else p.rebuild(*data);
    p.data=data;
    return p.track!=nullptr;
}

int AssSubtitleRenderer::render(int64_t timeMs,int frameW,int frameH,int storageW,int storageH,double fontScale){
    auto& p=*p_;
    p.images=nullptr;
    if(!p.track||frameW<1||frameH<1)return -1;
    frameW=std::min(frameW,16384);frameH=std::min(frameH,16384);
    bool resized=false;
    if(frameW!=p.frameW||frameH!=p.frameH){ass_set_frame_size(p.renderer,frameW,frameH);p.frameW=frameW;p.frameH=frameH;resized=true;}
    storageW=std::max(storageW,1);storageH=std::max(storageH,1);
    if(storageW!=p.storageW||storageH!=p.storageH){ass_set_storage_size(p.renderer,storageW,storageH);p.storageW=storageW;p.storageH=storageH;resized=true;}
    if(fontScale!=p.fontScale){ass_set_font_scale(p.renderer,fontScale);p.fontScale=fontScale;resized=true;}
    int change=0;
    p.images=ass_render_frame(p.renderer,p.track,timeMs,&change);
    return resized?2:change;
}

bool AssSubtitleRenderer::hasImages()const{return p_->images!=nullptr;}

void AssSubtitleRenderer::composite(uint32_t* canvas,int canvasW,int canvasH,int offsetX,int offsetY)const{
    if(!canvas)return;
    for(const ASS_Image* image=p_->images;image;image=image->next){
        if(image->w<=0||image->h<=0)continue;
        const uint32_t color=image->color;
        const uint32_t r=(color>>24)&0xFF,g=(color>>16)&0xFF,b=(color>>8)&0xFF,opacity=255-(color&0xFF);
        if(!opacity)continue;
        const int x0=std::max(0,offsetX+image->dst_x),y0=std::max(0,offsetY+image->dst_y);
        const int x1=std::min(canvasW,offsetX+image->dst_x+image->w),y1=std::min(canvasH,offsetY+image->dst_y+image->h);
        for(int y=y0;y<y1;++y){
            const unsigned char* mask=image->bitmap+size_t(y-offsetY-image->dst_y)*image->stride;
            uint32_t* row=canvas+size_t(y)*canvasW;
            for(int x=x0;x<x1;++x){
                const uint32_t coverage=mask[x-offsetX-image->dst_x];
                if(!coverage)continue;
                const uint32_t k=(coverage*opacity+127)/255,inverse=255-k;
                const uint32_t d=row[x];
                const uint32_t da=d>>24,dr=(d>>16)&0xFF,dg=(d>>8)&0xFF,db=d&0xFF;
                // Premultiplied "over": source colour scaled by its coverage.
                const uint32_t oa=k+(da*inverse+127)/255;
                const uint32_t orr=(r*k+dr*inverse+127)/255,og=(g*k+dg*inverse+127)/255,ob=(b*k+db*inverse+127)/255;
                row[x]=(oa<<24)|(orr<<16)|(og<<8)|ob;
            }
        }
    }
}
} // namespace veyra::ui