基于arm64架构国产操作系统|Linux下的RTMP|RTSP低延时直播播放器开发探究-阿里云开发者社区

基于arm64架构国产操作系统|Linux下的RTMP|RTSP低延时直播播放器开发探究

2024-08-13 293

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

本文涉及的产品

视觉智能开放平台，分割抠图1万点

视觉智能开放平台，视频通用资源包5000点

视觉智能开放平台，图像通用资源包5000点

简介： 这段内容讲述了国产操作系统背景下，大牛直播SDK针对国产操作系统与Linux平台发布的RTMP/RTSP直播播放SDK。此SDK支持arm64架构，基于X协议输出视频，采用PulseAudio和Alsa Lib处理音频，具备实时静音、快照、缓冲时间设定等功能，并支持H.265编码格式。此外，提供了示例代码展示如何实现多实例播放器的创建与管理，包括窗口布局调整、事件监听、视频分辨率变化和实时快照回调等关键功能。这一技术实现有助于提高直播服务的稳定性和响应速度，适应国产操作系统在各行业中的应用需求。

技术背景

2014年4月8日起，美国微软公司停止了对Windows XP SP3操作系统提供服务支持，这引起了社会和广大用户的广泛关注和对信息安全的担忧。而2020年对Windows7服务支持的终止再一次推动了国产系统的发展。工信部对此表示，将继续加大力度，支持Linux的国产操作系统的研发和应用，并希望用户可以使用国产操作系统。

为什么要发展国产操作系统？

技术自主性和信息安全：国家和政府机构通常认为拥有自主研发和掌握核心技术是保障国家信息安全和加强自主创新能力的重要举措。通过开发和商业化国产操作系统，可以降低对外国技术和软件的依赖，并减少潜在的信息泄露和安全风险。
降低技术依赖风险：依赖外国操作系统和软件可能面临技术封锁、供应中断或不稳定的问题。商业化国产操作系统可以减少对外部技术供应链的依赖，为国内企业和用户提供更可靠和稳定的软件解决方案，降低技术依赖风险。
满足国内市场需求：随着国内科技产业的快速发展，对于操作系统的需求也日益增长。国产操作系统可以更好地满足国内用户的需求，提供更贴近本地文化和习惯的用户界面和功能，提高用户的使用体验。
促进产业发展：国产操作系统的开发和应用可以带动相关产业的发展，包括硬件制造、软件开发、系统集成等。这有助于提升整个产业链的技术水平和竞争力，促进国内科技产业的升级和转型。
生态系统建设：发展国产操作系统有助于构建和完善自主可控的软件生态系统。通过鼓励和支持国内软件开发者在国产操作系统上进行应用开发，可以丰富应用生态，提高系统的可用性和易用性。

此外，随着云计算、大数据、人工智能等新兴技术的发展，操作系统作为基础设施的重要性日益凸显。发展国产操作系统可以为这些新兴技术提供更安全、更可靠的运行环境，推动相关产业的发展和创新。

综上所述，发展国产操作系统对于保障国家信息安全、降低技术依赖风险、满足国内市场需求、促进产业发展以及构建完善的生态系统等方面都具有重要意义。

技术实现

顺势而为，在发布arm64架构的国产操作系统|Linux平台的RTMP|RTSP直播播放SDK之前，大牛直播SDK（官方）的直播播放SDK用一句比较流行的广告语叫遥遥领先，我们更是在前几年已经发布了Linux X86_64架构的播放器，并得到了广泛的应用。

本次发布的可用于国产操作系统和Linux上的的RTMP|RTSP直播播放SDK, video输出基于X协议，audio输出采用PulseAudio和Alsa Lib实现。除了常规功能如实时静音、快照、buffer time设定、网络自动重连等，RTMP支持扩展H265播放（支持Enhanced RTMP H.265播放）, RTSP也支持H265播放。

大牛直播SDK发布的Linux平台播放器SDK支持多实例播放，相关代码如下：

/*
 * multi_player_demo.cpp
 * 
 * Author: daniusdk.com
 *
 * Copyright © 2017~2024 DaniuLive. All rights reserved.
 */
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <poll.h>
#include <errno.h>
#include <string>
#include <sstream>
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include "nt_sdk_linux_smart_log.h"
#include "nt_linux_smart_player_sdk.h"
#include "nt_player_sdk_wrapper.h"
....
const char* players_url_[]
{
    "rtsp://admin:daniulive12345@192.168.0.120:554/h264/ch1/main/av_stream",
    "rtsp://admin:daniulive12345@192.168.0.120:554/h264/ch1/main/av_stream",
    "rtsp://admin:admin123456@192.168.0.121:554/cam/realmonitor?channel=1&subtype=0",
    "rtsp://admin:admin123456@192.168.0.121:554/cam/realmonitor?channel=1&subtype=0",
};
int main(int argc, char *argv[])
{
    XInitThreads(); // X支持多线程, 必须调用
    NT_SDKLogInit();
    // SDK初始化
    SmartPlayerSDKAPI player_api;
    if (!NT_PlayerSDKInit(player_api))
    {
        fprintf(stderr, "SDK init failed.\n");
        return 0;
    }
    auto display = XOpenDisplay(nullptr);
    if (!display)
    {
        fprintf(stderr, "Cannot connect to X server\n");
        player_api.UnInit();
        return 0;
    }
    auto screen = DefaultScreen(display);
    auto root = XRootWindow(display, screen);
    XWindowAttributes root_win_att;
    if (!XGetWindowAttributes(display, root, &root_win_att))
    {
        fprintf(stderr, "Get Root window attri failed\n");
        player_api.UnInit();
        XCloseDisplay(display);
        return 0;
    }
    if (root_win_att.width < 100 || root_win_att.height < 100)
    {
        fprintf(stderr, "Root window size error.\n");
        player_api.UnInit();
        XCloseDisplay(display);
        return 0;
    }
    fprintf(stdout, "Root Window Size:%d*%d\n", root_win_att.width, root_win_att.height);
    int main_w = root_win_att.width / 2, main_h = root_win_att.height/2;
    auto black_pixel = BlackPixel(display, screen);
    auto white_pixel = WhitePixel(display, screen);
    auto main_wid = XCreateSimpleWindow(display, root, 0, 0, main_w, main_h, 0, white_pixel, black_pixel);
    if (!main_wid)
    {
        player_api.UnInit();
        XCloseDisplay(display);
        fprintf(stderr, "Cannot create main windows\n");
        return 0;
    }
    XSelectInput(display, main_wid, StructureNotifyMask | KeyPressMask);
    XMapWindow(display, main_wid);
    XStoreName(display, main_wid, win_base_title);
    std::vector<std::shared_ptr<NT_PlayerSDKWrapper> > players;
    for (auto url: players_url_)
    {
        auto i = std::make_shared<NT_PlayerSDKWrapper>(&player_api);
        i->SetDisplay(display);
        i->SetScreen(screen);
        i->SetURL(url);
        players.push_back(i);
        if ( players.size() > 3 )
            break;
    }
    auto border_w = 2;
    std::vector<NT_LayoutRect> layout_rects;
    SubWindowsLayout(main_w, main_h, border_w, static_cast<int>(players.size()), layout_rects);
    for (auto i = 0; i < static_cast<int>(players.size()); ++i)
    {
        assert(players[i]);
        players[i]->SetWindow(CreateSubWindow(display, screen, main_wid, layout_rects[i], border_w));
    }
    for (const auto& i : players)
    {
        assert(i);
        if (i->GetWindow())
            XMapWindow(display, i->GetWindow());
    }
    for (auto i = 0; i < static_cast<int>(players.size()); ++i)
    {
        assert(players[i]);
        // 第一路不静音, 其他全部静音
        players[i]->Start(0, i!=0, 1, false);
        //players[i]->Start(0, false, 1, false);
    }
    while (true)
    {
        while (MY_X11_Pending(display, 10))
        {
            XEvent xev;
            memset(&xev, 0, sizeof(xev));
            XNextEvent(display, &xev);
            if (xev.type == ConfigureNotify)
            {
                if (xev.xconfigure.window == main_wid)
                {
                    if (xev.xconfigure.width != main_w || xev.xconfigure.height != main_h)
                    {
                        main_w = xev.xconfigure.width;
                        main_h = xev.xconfigure.height;
                        SubWindowsLayout(main_w, main_h, border_w, static_cast<int>(players.size()), layout_rects);
                        for (auto i = 0; i < static_cast<int>(players.size()); ++i)
                        {
                            if (players[i]->GetWindow())
                            {
                                XMoveResizeWindow(display, players[i]->GetWindow(), layout_rects[i].x_, layout_rects[i].y_, layout_rects[i].w_, layout_rects[i].h_);
                            }
                        }
                    }
                }
                else
                {
                    for (const auto& i: players)
                    {
                        assert(i);
                        if (i->GetWindow() && i->GetWindow() == xev.xconfigure.window)
                        {
                            i->OnWindowSize(xev.xconfigure.width, xev.xconfigure.height);
                        }
                    }
                }
            }
            else if (xev.type == KeyPress)
            {
                if (xev.xkey.keycode == XKeysymToKeycode(display, XK_Escape))
                {
                    fprintf(stdout, "ESC Key Press\n");
                    for (const auto& i : players)
                    {
                        i->Stop();
                        if (i->GetWindow())
                        {
                            XDestroyWindow(display, i->GetWindow());
                            i->SetWindow(None);
                        }
                    }
                    players.clear();
                    
                    XDestroyWindow(display, main_wid);
                    XCloseDisplay(display);
                    player_api.UnInit();
                    fprintf(stdout, "Close Players....\n");
                    return 0;
                }
            }
        }
    }
}

开始播放、停止播放封装实现

bool NT_PlayerSDKWrapper::Start(int buffer, bool is_mute, int render_scale_mode, bool is_only_dec_key_frame)
{
    if (is_playing_)
        return false;
    if (url_.empty())
        return false;
    if (!OpenHandle(url_, buffer))
        return false;
    assert(handle_ && handle_->Handle());
    // 音频参数
    player_api_->SetMute(handle_->Handle(), is_mute ? 1 : 0);
    player_api_->SetIsOutputAudioDevice(handle_->Handle(), 1);
    player_api_->SetAudioOutputLayer(handle_->Handle(), 0); // 使用pluse 或者 alsa播放, 两个可以选择一个
    // 视频参数
    player_api_->SetVideoSizeCallBack(handle_->Handle(), this, &NT_Player_SDK_WRAPPER_OnVideoSizeHandle);
    //player_api_->SetXDisplayName(handle_->Handle(), NULL);
    player_api_->SetXScreenNumber(handle_->Handle(),screen_);
    player_api_->SetRenderXWindow(handle_->Handle(), window_);
    player_api_->SetRenderScaleMode(handle_->Handle(), render_scale_mode);
    player_api_->SetRenderTextureScaleFilterMode(handle_->Handle(), 3);
    player_api_->SetOnlyDecodeVideoKeyFrame(handle_->Handle(), is_only_dec_key_frame ? 1 : 0);
    auto ret = player_api_->StartPlay(handle_->Handle());
    if (NT_ERC_OK != ret)
    {
        ResetHandle();
        return false;
    }
    is_playing_ = true;
    return true;
}
void NT_PlayerSDKWrapper::Stop()
{
    if (!is_playing_)
        return;
    assert(handle_);
    player_api_->StopPlay(handle_->Handle());
    video_width_ = 0;
    video_height_ = 0;
    ResetHandle();
    is_playing_ = false;
}

Event回调

bool NT_PlayerSDKWrapper::AttachHandle(const std::shared_ptr<NT_SDK_HandleWrapper>& handle)
{
    if (is_playing_)
        return false;
    handle_ = handle;
    if (handle_)
    {
        handle_->AddEventHandler(shared_from_this());
    }
    return true;
}

视频分辨率回调

extern "C" NT_VOID NT_CALLBACK NT_Player_SDK_WRAPPER_OnVideoSizeHandle(NT_HANDLE handle, NT_PVOID user_data,
    NT_INT32 width, NT_INT32 height)
{
    auto sdk_wrapper = reinterpret_cast<NT_PlayerSDKWrapper*>(user_data);
    if (nullptr == sdk_wrapper)
        return;
    sdk_wrapper->VideoSizeHandle(handle, width, height);
}

实时快照回调

extern "C" NT_VOID NT_CALLBACK NT_Player_SDK_WRAPPER_OnCaptureImageCallBack(NT_HANDLE handle, NT_PVOID user_data, NT_UINT32 result, NT_PCSTR file_name)
{
    auto sdk_wrapper = reinterpret_cast<NT_PlayerSDKWrapper*>(user_data);
    if (nullptr == sdk_wrapper)
        return;
    sdk_wrapper->CaptureImageHandle(handle, result, file_name);
}