Vulkan视频解码decode显示display之同步

在ReleaseDisplayedPicture函数中消耗图片资源并且显示display完成，设置两个标志m_hasConsummerSignalFence = true 和m_hasConsummerSignalSemaphore = true
    virtual int32_t ReleaseDisplayedPicture(DecodedFrameRelease** pDecodedFramesRelease, uint32_t numFramesToRelease)
    {
        std::lock_guard<std::mutex> lock(m_displayQueueMutex);
        for (uint32_t i = 0; i < numFramesToRelease; i++) {
            const DecodedFrameRelease* pDecodedFrameRelease = pDecodedFramesRelease[i];
            int picId = pDecodedFrameRelease->pictureIndex;
            assert((picId >= 0) && ((uint32_t)picId < m_perFrameDecodeImageSet.size()));

            assert(m_perFrameDecodeImageSet[picId].m_decodeOrder == pDecodedFrameRelease->decodeOrder);
            assert(m_perFrameDecodeImageSet[picId].m_displayOrder == pDecodedFrameRelease->displayOrder);

            assert(m_ownedByDisplayMask & (1 << picId));
            m_ownedByDisplayMask &= ~(1 << picId);
            m_perFrameDecodeImageSet[picId].m_inDecodeQueue = false;
            m_perFrameDecodeImageSet[picId].m_ownedByConsummer = false;
            m_perFrameDecodeImageSet[picId].Release();

            m_perFrameDecodeImageSet[picId].m_hasConsummerSignalFence = pDecodedFrameRelease->hasConsummerSignalFence;
            m_perFrameDecodeImageSet[picId].m_hasConsummerSignalSemaphore = pDecodedFrameRelease->hasConsummerSignalSemaphore;
        }
        return 0;
    }

ReleaseDisplayedPicture被ReleaseFrame调用，pLastDecodedFrame就是当前已经解码的帧

.....................................

        m_videoQueue->ReleaseFrame(pLastDecodedFrame);

        pLastDecodedFrame->Reset();

        bool endOfStream = false;
        int32_t numVideoFrames = 0;

        numVideoFrames = m_videoQueue->GetNextFrame(pLastDecodedFrame, &endOfStream);

.............................................

//-----------------------------------------------------------------------

这两个标志一旦设置为true，在QueuePictureForDecode函数中，将设置pFrameSynchronizationInfo->frameConsumerDoneFence和 pFrameSynchronizationInfo->frameConsumerDoneSemaphore，返回后使用，同时重置两个标志为false

    virtual int32_t QueuePictureForDecode(int8_t picId, VkParserDecodePictureInfo* pDecodePictureInfo,
                                          ReferencedObjectsInfo* pReferencedObjectsInfo,
                                          FrameSynchronizationInfo* pFrameSynchronizationInfo)
    {
        if (pFrameSynchronizationInfo->hasFrameCompleteSignalFence) {
            pFrameSynchronizationInfo->frameCompleteFence = m_perFrameDecodeImageSet[picId].m_frameCompleteFence;
            if (pFrameSynchronizationInfo->frameCompleteFence) {
                m_perFrameDecodeImageSet[picId].m_hasFrameCompleteSignalFence = true;
            }
        }

        if (m_perFrameDecodeImageSet[picId].m_hasConsummerSignalFence) {
            pFrameSynchronizationInfo->frameConsumerDoneFence = m_perFrameDecodeImageSet[picId].m_frameConsumerDoneFence;
            m_perFrameDecodeImageSet[picId].m_hasConsummerSignalFence = false;
        }

        if (pFrameSynchronizationInfo->hasFrameCompleteSignalSemaphore) {
            pFrameSynchronizationInfo->frameCompleteSemaphore = m_perFrameDecodeImageSet[picId].m_frameCompleteSemaphore;
            if (pFrameSynchronizationInfo->frameCompleteSemaphore) {
                m_perFrameDecodeImageSet[picId].m_hasFrameCompleteSignalSemaphore = true;
            }
        }

        if (m_perFrameDecodeImageSet[picId].m_hasConsummerSignalSemaphore) {
            pFrameSynchronizationInfo->frameConsumerDoneSemaphore = m_perFrameDecodeImageSet[picId].m_frameConsumerDoneSemaphore;
            m_perFrameDecodeImageSet[picId].m_hasConsummerSignalSemaphore = false;
        }
.................

}

返回后如何使用pFrameSynchronizationInfo->frameConsumerDoneFence和 pFrameSynchronizationInfo->frameConsumerDoneSemaphore,代码如下：

    VkFence frameCompleteFence = frameSynchronizationInfo.frameCompleteFence;
    VkSemaphore frameCompleteSemaphore = frameSynchronizationInfo.frameCompleteSemaphore;
    VkSemaphore frameConsumerDoneSemaphore = frameSynchronizationInfo.frameConsumerDoneSemaphore;

    uint32_t waitSemaphoreCount = 0;
    if (frameConsumerDoneSemaphore != VK_NULL_HANDLE) {
        waitSemaphores[waitSemaphoreCount] = frameConsumerDoneSemaphore;
        waitSemaphoreCount++;
    }

    VkSubmitInfo submitInfo = { VK_STRUCTURE_TYPE_SUBMIT_INFO, nullptr };
    const VkPipelineStageFlags videoDecodeSubmitWaitStages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
    submitInfo.pNext = (m_hwLoadBalancingTimelineSemaphore != VK_NULL_HANDLE) ? &timelineSemaphoreInfos : nullptr;
    submitInfo.waitSemaphoreCount = waitSemaphoreCount;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = &videoDecodeSubmitWaitStages;
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &frameDataSlot.commandBuffer;
    submitInfo.signalSemaphoreCount = signalSemaphoreCount;
    submitInfo.pSignalSemaphores = signalSemaphores;

    assert(VK_NOT_READY == m_vkDevCtx->GetFenceStatus(*m_vkDevCtx, videoDecodeCompleteFence));
    VkResult result = m_vkDevCtx->MultiThreadedQueueSubmit(VulkanDeviceContext::DECODE, m_currentVideoQueueIndx,
                                                           1, &submitInfo, videoDecodeCompleteFence);

拷贝pictureIndex视频帧，并进行等待解码完成并且设置显示完成信号

    virtual int32_t DequeueDecodedPicture(VulkanDecodedFrame* pDecodedFrame)
    {


            if (m_perFrameDecodeImageSet[pictureIndex].m_hasFrameCompleteSignalFence) {
                pDecodedFrame->frameCompleteFence = m_perFrameDecodeImageSet[pictureIndex].m_frameCompleteFence;
                m_perFrameDecodeImageSet[pictureIndex].m_hasFrameCompleteSignalFence = false;
            } else {
                pDecodedFrame->frameCompleteFence = VkFence();
            }

            if (m_perFrameDecodeImageSet[pictureIndex].m_hasFrameCompleteSignalSemaphore) {
                pDecodedFrame->frameCompleteSemaphore = m_perFrameDecodeImageSet[pictureIndex].m_frameCompleteSemaphore;
                m_perFrameDecodeImageSet[pictureIndex].m_hasFrameCompleteSignalSemaphore = false;
            } else {
                pDecodedFrame->frameCompleteSemaphore = VkSemaphore();
            }

            pDecodedFrame->frameConsumerDoneFence = m_perFrameDecodeImageSet[pictureIndex].m_frameConsumerDoneFence;
            pDecodedFrame->frameConsumerDoneSemaphore = m_perFrameDecodeImageSet[pictureIndex].m_frameConsumerDoneSemaphore;

            pDecodedFrame->timestamp = m_perFrameDecodeImageSet[pictureIndex].m_timestamp;
            pDecodedFrame->decodeOrder = m_perFrameDecodeImageSet[pictureIndex].m_decodeOrder;
            pDecodedFrame->displayOrder = m_perFrameDecodeImageSet[pictureIndex].m_displayOrder;

            pDecodedFrame->queryPool = m_queryPool;
            pDecodedFrame->startQueryId = pictureIndex;
            pDecodedFrame->numQueries = 1;

}

//pDecodedFrame传递给DrawFrame最后一个参数pLastDecodedFrame

    VkResult result = DrawFrame(renderIndex,
                                waitSemaphoreCount,
                                pWaitSemaphores,
                                signalSemaphoreCount,
                                pSignalSemaphores,
                                pLastDecodedFrame)

VkResult VulkanFrame<FrameDataType>::DrawFrame( int32_t            renderIndex,
                                                uint32_t           waitSemaphoreCount,
                                                const VkSemaphore* pWaitSemaphores,
                                                uint32_t           signalSemaphoreCount,
                                                const VkSemaphore* pSignalSemaphores,
                                                FrameDataType*     inFrame)

{


    const uint32_t maxWaitSemaphores = 2;
    uint32_t numWaitSemaphores = 0;
    VkSemaphore waitSemaphores[maxWaitSemaphores] = {};

    assert(waitSemaphoreCount <= 1);
    if ((waitSemaphoreCount > 0) && (pWaitSemaphores != nullptr)) {

//这个是等待上一次present完成
        waitSemaphores[numWaitSemaphores++] = *pWaitSemaphores;
    }

    if (inFrame && (inFrame->frameCompleteSemaphore != VkSemaphore())) {

//等待解码完成信号
        waitSemaphores[numWaitSemaphores++] = inFrame->frameCompleteSemaphore;
    }
    assert(numWaitSemaphores <= maxWaitSemaphores);

    const uint32_t maxSignalSemaphores = 2;
    uint32_t numSignalSemaphores = 0;
    VkSemaphore signalSemaphores[maxSignalSemaphores] = {};

    assert(signalSemaphoreCount <= 1);
    if ((signalSemaphoreCount > 0) && (pSignalSemaphores != nullptr)) {
        signalSemaphores[numSignalSemaphores++] = *pSignalSemaphores;
    }

    if (inFrame && (inFrame->frameConsumerDoneSemaphore != VkSemaphore())) {

//显示完成消费信号激活，这样这个图片资源才能被用来继续解码新视频帧，解码函数中需要等待这个frameConsumerDoneSemaphore有信号才能使用这个图片资源解码
        signalSemaphores[numSignalSemaphores++] = inFrame->frameConsumerDoneSemaphore;
        inFrame->hasConsummerSignalSemaphore = true;
    }
    assert(numSignalSemaphores <= maxSignalSemaphores);

    if (frameConsumerDoneFence != VkFence()) {
        inFrame->hasConsummerSignalFence = true;
    }


    // Wait for the image to be owned and signal for render completion
    VkPipelineStageFlags primaryCmdSubmitWaitStages[2] = { VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                                           VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT };
    VkSubmitInfo primaryCmdSubmitInfo = VkSubmitInfo();
    primaryCmdSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    primaryCmdSubmitInfo.pWaitDstStageMask = primaryCmdSubmitWaitStages;
    primaryCmdSubmitInfo.commandBufferCount = 1;

    primaryCmdSubmitInfo.waitSemaphoreCount = numWaitSemaphores;
    primaryCmdSubmitInfo.pWaitSemaphores = numWaitSemaphores ? waitSemaphores : NULL;
    primaryCmdSubmitInfo.pCommandBuffers = pPerDrawContext->commandBuffer.GetCommandBuffer();

    primaryCmdSubmitInfo.signalSemaphoreCount = numSignalSemaphores;
    primaryCmdSubmitInfo.pSignalSemaphores = numSignalSemaphores ? signalSemaphores : NULL;

    // For fence/sync debugging
    if (false && inFrame && inFrame->frameCompleteFence) {
        result = m_vkDevCtx->WaitForFences(*m_vkDevCtx, 1, &inFrame->frameCompleteFence, true, 100 * 1000 * 1000);
        assert(result == VK_SUCCESS);
        if (result != VK_SUCCESS) {
            fprintf(stderr, "\nERROR: WaitForFences() result: 0x%x\n", result);
        }
        result = m_vkDevCtx->GetFenceStatus(*m_vkDevCtx, inFrame->frameCompleteFence);
        assert(result == VK_SUCCESS);
        if (result != VK_SUCCESS) {
            fprintf(stderr, "\nERROR: GetFenceStatus() result: 0x%x\n", result);
        }
    }

    result = m_vkDevCtx->MultiThreadedQueueSubmit(VulkanDeviceContext::GRAPHICS, 0, 1, &primaryCmdSubmitInfo, frameConsumerDoneFence);
    if (result != VK_SUCCESS) {
        assert(result == VK_SUCCESS);
        fprintf(stderr, "\nERROR: MultiThreadedQueueSubmit() result: 0x%x\n", result);
        return result;
    }

    if (false && (frameConsumerDoneFence != VkFence())) { // For fence/sync debugging
        const uint64_t fenceTimeout = 100 * 1000 * 1000 /* 100 mSec */;
        result = m_vkDevCtx->WaitForFences(*m_vkDevCtx, 1, &frameConsumerDoneFence, true, fenceTimeout);
        assert(result == VK_SUCCESS);
        if (result != VK_SUCCESS) {
            fprintf(stderr, "\nERROR: WaitForFences() result: 0x%x\n", result);
        }
        result = m_vkDevCtx->GetFenceStatus(*m_vkDevCtx, frameConsumerDoneFence);
        assert(result == VK_SUCCESS);
        if (result != VK_SUCCESS) {
            fprintf(stderr, "\nERROR: GetFenceStatus() result: 0x%x\n", result);
        }
    }

#if 0 // for testing VK_KHR_external_fence_fd
    int fd = -1; // VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
    const VkFenceGetFdInfoKHR getFdInfo =  { VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, NULL, data.lastDecodedFrame.frameConsumerDoneFence, VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT};
    res = m_vkDevCtx->GetFenceFdKHR(*m_vkDevCtx, &getFdInfo, &fd);
    close(fd);
#endif

    m_frameDataIndex = (m_frameDataIndex + 1) % m_frameData.size();

    return result;

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/72458.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

网络空间安全（32）Kali MSF基本介绍

网络空间安全（32）Kali MSF基本介绍

前言 Metasploit Framework&#xff08;简称MSF&#xff09;是一款功能强大的开源安全漏洞检测工具&#xff0c;被广泛应用于渗透测试中。它内置了数千个已知的软件漏洞&#xff0c;并持续更新以应对新兴的安全威胁。MSF不仅限于漏洞利用&#xff0c;还包括信息收集、漏洞探测和…
阅读更多...
设计模式学习记录

设计模式学习记录

设计模式23种 创建型抽象工厂模式工厂模式生成器模式原型模式单例模式 结构型适配器模式桥接模式组合模式装饰模式外观模式享元模式代理模式 行为型责任链模式命令模式解释器模式迭代器模式中介者模式备忘录模式观察者模式状态模式策略模式模版方法模式访问者模式 创建型 与对…
阅读更多...
2.5 python接口编程

2.5 python接口编程

在现代软件开发的复杂生态系统中&#xff0c;不同系统、模块之间的交互协作至关重要。接口编程作为一种关键机制&#xff0c;定义了组件之间的通信规范与交互方式。Python 凭借其卓越的灵活性、丰富的库资源以及简洁易读的语法&#xff0c;在接口编程领域占据了重要地位&#x…
阅读更多...
mesh开发解析

mesh开发解析

开源的Mesh网络协议栈及相关项目&#xff1a; 1.B.A.T.M.A.N.(Better Approach to Mobile Ad-hoc Networking)• 简介&#xff1a;B.A.T.M.A.N.是一种用于多跳自组织网络的路由协议&#xff0c;适用于无线Mesh网络。它通过优化数据传输路径&#xff0c;确保网络的高可靠性和动…
阅读更多...
PyTorch PINN实战：用深度学习求解微分方程

PyTorch PINN实战：用深度学习求解微分方程

在人工智能与计算数学的交汇点&#xff0c;物理信息神经网络&#xff08;Physics-Informed Neural Networks&#xff0c;PINN&#xff09;正引领着一场求解微分方程的革命。传统上&#xff0c;微分方程是描述自然现象和工程问题中各种关系的重要工具&#xff0c;但其求解往往依…
阅读更多...
【WiFi 7核心技术及未来挑战】

【WiFi 7核心技术及未来挑战】

作为刚刚开始从事这一领域的人&#xff0c;浅浅学习了一下WiFi 7&#xff08;IEEE 802.11be&#xff09;。Wi-Fi 7发展迅速&#xff0c;提供前所未有的速度、更低的延迟和更高的可靠性。但从频谱政策到能效挑战&#xff0c;再到成本&#xff0c;仍有许多问题亟待解决。 Wi-Fi 7…
阅读更多...
Oracle Linux Server 7.9安装fail2ban

Oracle Linux Server 7.9安装fail2ban

yum search oracle-epel-release yum install oracle-epel-release-el7 search fail2ban yum install fail2ban nano /etc/fail2ban/jail.d/00-firewalld.conf # defalut这里是设定全局设置&#xff0c;如果下面的监控没有设置就以全局设置的值设置。 [DEFAULT] # 用于指定哪…
阅读更多...
目标在哪里？——寻找人生的意义与方向

目标在哪里？——寻找人生的意义与方向

在职场中&#xff0c;许多人都会经历这样的困惑&#xff1a;工作看似顺利&#xff0c;却逐渐失去了成就感和成长感。一位在500强企业工作的学员就遇到了这样的问题。她曾考虑过转型做培训&#xff0c;但苦于找不到明确的切入点&#xff0c;对未来的目标感到迷茫。她不禁问自己&…
阅读更多...
C++类与对象——拷贝构造与运算符重载

C++类与对象——拷贝构造与运算符重载

拷贝构造函数和赋值运算符重载就是C类默认六个函数之二。 拷贝构造函数&#xff1a; 如果⼀个构造函数的第⼀个参数是自身类类型的引用&#xff0c;且任何额外的参数都有默认值&#xff0c;则此构造函数 也叫做拷贝构造函数&#xff0c;也就是说拷贝构造是⼀个特殊的构造函数…
阅读更多...
破碎的誓言

破碎的誓言

破碎的誓言 在秋风的呢喃中&#xff0c;落叶轻叹&#xff0c; 昔日的誓言&#xff0c;如烟消散。 你的眼眸&#xff0c;曾是我星辰的指引&#xff0c; 如今&#xff0c;却成了最深的迷惘。 欺骗的利刃&#xff0c;刺穿了信任的堡垒&#xff0c; 我的心&#xff0c;如裂开…
阅读更多...
AD画板学习

AD画板学习

AD画板 01 课程简介及学习目标 &#xff08;1&#xff09;能熟练的新建项目文件、原理图文件、PCB文件且修改文件名&#xff0c;并知道文件保存的位置&#xff1b; &#xff08;2&#xff09;会设置原理图编辑器的工作环境&#xff0c;会自底向上绘制层次原理图&#xff1b; …
阅读更多...
Linux：进程程序替换

Linux：进程程序替换

目录 前言 一 进程程序替换的概念 二 进程程序替换的原理 三 为什么需要进行进程程序替换 四 如何进行进程程序替换 1. 进程替换函数 ➊ execl()函数 ➋execv()函数 ➌execlp()函数 ➍execle()函数 ➎execve()* 前言 一般情况下&#xff0c;对应的语言写的程序只…
阅读更多...
基于变分推理与 Best‑of‑N 策略的元 Prompt 自动生成与优化框架

基于变分推理与 Best‑of‑N 策略的元 Prompt 自动生成与优化框架

摘要 本文提出了一种融合变分推理与 Best‑of‑N 策略的元 Prompt 自动生成与优化框架&#xff0c;通过高度参数化的模板、随机扰动采样及多指标评分机制&#xff0c;实现从初始提示生成到最终输出的动态优化。同时&#xff0c;针对实际应用中对自适应参数调整、深层语义理解、…
阅读更多...
Umi-OCR 全家桶

Umi-OCR 全家桶

介绍&#xff1a; 下载 访问官网地址 https://github.com/hiroi-sora/umi-ocrhttps://github.com/hiroi-sora/umi-ocr 点击下载&#xff08;.exe 文件 安装即可&#xff09; 桌面使用 安装完毕后去安装路径下点击 Umi-OCR.exe &#xff08;默认不会生成桌面的快捷方式&…
阅读更多...
2023南京理工大学计算机复试上机真题

2023南京理工大学计算机复试上机真题

2023南京理工大学计算机复试上机真题 2023南京理工大学计算机复试机试真题 历年南京理工大学计算机复试上机真题 在线评测&#xff1a;传送门&#xff1a;pgcode.cn 括号匹配二 题目描述 苗苗今天刚刚学会使用括号&#xff0c;不过他分不清小括号&#xff0c;中括号&#…
阅读更多...
Conda 常规用法指南

Conda 常规用法指南

Conda 常规用法指南 1. Conda 简介 Conda 是一个开源的包管理和环境管理系统&#xff0c;主要用于 Python 和其他编程语言的开发环境。它能够方便地安装、更新和管理依赖项&#xff0c;使得不同项目可以使用不同的 Python 版本和库。 2. Conda 环境管理 2.1 创建新的环境 conda…
阅读更多...
非零初始条件系统的传递函数分析

非零初始条件系统的传递函数分析

非零初始条件系统的传递函数分析 在传递函数的定义中&#xff0c;通常假设系统满足零初始条件。然而在实际应用中&#xff0c;很多系统需要处理非零初始状态。为了探讨这一问题&#xff0c;我们以一个一阶微分方程为例进行分析。 一、一阶系统的分析 考虑以下一阶微分方程&a…
阅读更多...
centos7安装时采用的默认分区（比如：/dev/sda3的对应挂载点是/），如何对系统扩容？

centos7安装时采用的默认分区（比如：/dev/sda3的对应挂载点是/），如何对系统扩容？

‌非LVM分区扩容方案‌ 若 /dev/sda3 是‌非LVM分区‌且存储重要数据&#xff0c;可通过 ‌直接扩展分区容量‌ ‌调整文件系统‌ 实现扩容&#xff0c;无需重建LVM或格式化分区‌。以下是具体步骤&#xff1a; ‌1. 扩展物理磁盘&#xff08;虚拟机场景&#xff09;‌ ‌关…
阅读更多...
Axios简单说明，快速上手

Axios简单说明，快速上手

Ajax&#xff1a;异步的JavaScript和XML 作用&#xff1a; 数据交换异步交互 Axios&#xff1a;就是对原生Ajax进行封装&#xff0c;简化书写&#xff0c;快速开发 使用逻辑&#xff1a; 首先要安装Axios&#xff0c;可以通过npm在项目中安装&#xff1a; 打开命令行工具…
阅读更多...
模型评估——acc、P、R、F值、交叉验证、K折交叉验证

模型评估——acc、P、R、F值、交叉验证、K折交叉验证

模型评估&#xff1a;对预测函数地预测精度的评估。 多重回归&#xff1a;涉及三个及其以上的变量的回归问题。 评估模型的方法&#xff1a; 交叉验证&#xff1a;将数据集分成测试集和训练集&#xff0c;可以采用3&#xff1a;7或者2&#xff1a;8的比例方式进行划分&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023