C++使用FFmpeg读取UVC摄像头推流，流媒体服务器用Go实现，摄像头是USB免驱摄像头



关于Go流媒体服务器的实现请看：[FFmpe读取UVC摄像头推流](https://phaee.com/post/19#FFmpe%E8%AF%BB%E5%8F%96UVC%E6%91%84%E5%83%8F%E5%A4%B4%E6%8E%A8%E6%B5%81)

FFmpeg版本：n7.1

注意链接库的顺序：

` avformat avcodec avdevice avfilter  avutil swresample swscale `

``` C++

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>

#include "libavdevice/avdevice.h"
}


int main() {
    // 初始化FFmpeg库
    avdevice_register_all();
    avformat_network_init();

    // 打开视频设备
    AVFormatContext *input_ctx = nullptr;
    AVDictionary *options = nullptr;
    av_dict_set(&options, "input_format", "mjpeg", 0);
    if (avformat_open_input(&input_ctx, "/dev/video0", nullptr, &options) < 0) {
        fprintf(stderr, "无法打开视频输入设备。\n");
        return -1;
    }

    // 查找视频流
    if (avformat_find_stream_info(input_ctx, nullptr) < 0) {
        fprintf(stderr, "无法获取视频流信息。\n");
        return -1;
    }

    // 创建一个用于接收解码器的指针变量
    const AVCodec *decoder = nullptr;

    // 使用二级指针传递 decoder 变量的地址
    int video_stream_index = av_find_best_stream(input_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);

    if (video_stream_index < 0) {
        fprintf(stderr, "无法找到视频流。\n");
        return -1;
    }

    // 打开解码器
    AVCodecContext *decoder_ctx = avcodec_alloc_context3(decoder);
    avcodec_parameters_to_context(decoder_ctx, input_ctx->streams[video_stream_index]->codecpar);
    if (avcodec_open2(decoder_ctx, decoder, nullptr) < 0) {
        fprintf(stderr, "无法打开解码器。\n");
        return -1;
    }

    // 创建输出格式上下文
    AVFormatContext *output_ctx = nullptr;
    avformat_alloc_output_context2(&output_ctx, nullptr, "rtsp", "rtsp://192.168.1.31:8554/live.sdp");
    if (!output_ctx) {
        fprintf(stderr, "无法创建输出上下文。\n");
        return -1;
    }

    // 设置编码器
    const AVCodec *encoder = avcodec_find_encoder(AV_CODEC_ID_MPEG4);

    AVCodecContext *encoder_ctx = avcodec_alloc_context3(encoder);
    encoder_ctx->bit_rate = 400000;
    encoder_ctx->width = decoder_ctx->width;
    encoder_ctx->height = decoder_ctx->height;
    encoder_ctx->time_base = {1, 25};
    encoder_ctx->framerate = {25, 1};
    encoder_ctx->gop_size = 10;
    encoder_ctx->max_b_frames = 1;
    encoder_ctx->pix_fmt = AV_PIX_FMT_YUV420P;

    av_opt_set(encoder_ctx->priv_data, "preset", "ultrafast", 0);
    av_opt_set(encoder_ctx->priv_data, "tune", "zerolatency", 0);

    if (avcodec_open2(encoder_ctx, encoder, nullptr) < 0) {
        fprintf(stderr, "无法打开编码器。\n");
        return -1;
    }

    // 创建并添加输出流
    AVStream *out_stream = avformat_new_stream(output_ctx, nullptr);
    avcodec_parameters_from_context(out_stream->codecpar, encoder_ctx);

    // 打开输出URL
    if (!(output_ctx->oformat->flags & AVFMT_NOFILE)) {
        if (avio_open(&output_ctx->pb, "rtsp://192.168.129.191:8554/live.sdp", AVIO_FLAG_WRITE) < 0) {
            fprintf(stderr, "无法打开输出文件。\n");
            return -1;
        }
    }

    // 写文件头
    avformat_write_header(output_ctx, nullptr);

    // 初始化帧数据和转换器
    AVFrame *frame = av_frame_alloc();
    AVPacket *packet = av_packet_alloc();
    AVFrame *yuv_frame = av_frame_alloc();
    yuv_frame->format = encoder_ctx->pix_fmt;
    yuv_frame->width = encoder_ctx->width;
    yuv_frame->height = encoder_ctx->height;
    av_frame_get_buffer(yuv_frame, 0);

    struct SwsContext *sws_ctx =
        sws_getContext(decoder_ctx->width, decoder_ctx->height, decoder_ctx->pix_fmt, encoder_ctx->width,
                       encoder_ctx->height, encoder_ctx->pix_fmt, SWS_BICUBIC, nullptr, nullptr, nullptr);

    // 循环读取并编码帧
    while (av_read_frame(input_ctx, packet) >= 0) {
        if (packet->stream_index == video_stream_index) {
            if (avcodec_send_packet(decoder_ctx, packet) == 0) {
                while (avcodec_receive_frame(decoder_ctx, frame) == 0) {
                    // 转换帧格式
                    sws_scale(sws_ctx, frame->data, frame->linesize, 0, frame->height, yuv_frame->data,
                              yuv_frame->linesize);

                    // 发送帧到编码器
                    if (avcodec_send_frame(encoder_ctx, yuv_frame) == 0) {
                        AVPacket encoded_pkt;
                        av_init_packet(&encoded_pkt);
                        encoded_pkt.data = nullptr;
                        encoded_pkt.size = 0;

                        while (avcodec_receive_packet(encoder_ctx, &encoded_pkt) == 0) {
                            // 推送编码后的数据
                            encoded_pkt.stream_index = out_stream->index;
                            av_interleaved_write_frame(output_ctx, &encoded_pkt);
                            av_packet_unref(&encoded_pkt);
                        }
                    }
                }
            }
        }
        av_packet_unref(packet);
    }

    // 写文件尾并清理资源
    av_write_trailer(output_ctx);
    av_frame_free(&frame);
    av_frame_free(&yuv_frame);
    av_packet_free(&packet);
    avcodec_free_context(&decoder_ctx);
    avcodec_free_context(&encoder_ctx);
    avformat_close_input(&input_ctx);
    avio_closep(&output_ctx->pb);
    avformat_free_context(output_ctx);
    sws_freeContext(sws_ctx);
    avformat_network_deinit();

    return 0;
}




```

C++使用FFmpeg读取UVC摄像头推流

Web的三员大将——HTML、CSS、JavaScript，HTML负责架构，CSS负责视觉效果，而JavaScript则是负责逻辑交互，各司其职，使得Web简易上手，各种UI组件库如雨后春笋。 QT则背靠C++，坐拥其得力干将QML，QML以其简洁的语法和强大的UI设计能力，使得QT在GUI框架中炙手可热。当QT的性能融合Web的UI组件，会有怎么样的效果呢？



环境说明：

C++: Apple clang version 15.0.0

QT: v6.5

Nodejs: v22.5

npm: v10.8.2

Vue cil: @vue/cli 5.0.8

需要的环境有qt，C++编译器，nodejs，npm，vue/cli，Qt Creator 和 VS Code
# QT融合HTML
## 创建QT项目

1.创建QT项目，打开Qt Creator,选择'Qt Quick application'

![创建项目](/static/img/c6dab93dc1912eac33c9917f9dfeebd3.clipboard-2024-08-11.webp)


创建完项目之后将会得到以下结构：


![image.png](/static/img/26e755fdc3356e0dc27e53dc50c36f69.image.webp)



接下来，再创建一个新文件，暂且命名test.html，注意要添加到cmake的，文件管理器或者vim创建的需要修改CMakeLists.txt。

![image.png](/static/img/cb948323a2d0921a5e3b0314edfc2b45.image.webp)
注意检查CMakeLists.txt的qt_add_qml_module：
```

qt_add_qml_module(appQT-Vue
    URI QT-Vue
    VERSION 1.0
    QML_FILES
        Main.qml
        RESOURCES test.html
)
```
若出现 RESOURCES test.html则说明导入正确,没有则手动加入。


2.编写html代码

在test.html中写入
``` html
<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <title>Login Page</title>
    <style>
        /* 添加一些基本的样式 */
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f4;
        }
        form {
            background-color: #fff;
            padding: 20px;
            margin: 20px auto;
            max-width: 500px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
        }
        label {
            display: block;
            margin-bottom: 10px;
        }
        input[type="text"],
        input[type="password"] {
            display: block;
            width: 100%;
            padding: 10px;
            margin-bottom: 20px;
            border: 1px solid #ccc;
            border-radius: 4px;
            box-sizing: border-box;
        }
        button[type="submit"] {
            background-color: #4CAF50;
            color: #fff;
            padding: 10px 20px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        button[type="submit"]:hover {
            background-color: #3e8e41;
        }
    </style>
</head>
<body>
    <form>
        <h1>Login</h1>
        <label for="username">用户名:</label>
        <input type="text" id="username" name="username">

        <label for="password">密码:</label>
        <input type="password" id="password" name="password">

        <button type="submit">登陆</button>
    </form>
</body>
</html>

```

3.修改Main.qml，加入webengineView，把url设置为test.html
``` c++
import QtQuick 2.15
import QtWebEngine 1.15

Window {
    width: 640
    height: 480
    visible: true
    title: qsTr("Hello World")

    WebEngineView {
            id:webview
            z:100
            anchors.fill: parent
            url: Qt.resolvedUrl("test.html")
        }
}
```
4.编译运行项目，发现html内容可以顺利加载了

![image.png](/static/img/207337bec0ce85b3709d638d09bf2a9c.image.webp)

但是，数据交互还尚未实现，也就是C++和JS还没能互相通信呢。接下来可以通过qwebchannel.js搭桥，让C++和JS在QT中通信。想了解qwebchannel.js的具体实现可以看看：
[qwebchannel.js的源码地址](https://github.com/qt/qtwebchannel/blob/6.5/examples/webchannel/shared/qwebchannel.js)
当然为了方便项目演示，直接把qwebchannel.js的源代码复制，然后在项目根目录新建一个qwebchannel.js粘贴源代码（注意需要加入cmake）。回到html文件中再head标签里面加入
```html
<script src="qwebchannel.js"></script>
```
这个时候CMakeLists.txt应该要有
```
qt_add_qml_module(appQT-Vue
    URI QT-Vue
    VERSION 1.0
    QML_FILES
        Main.qml
        RESOURCES test.html
        QML_FILES qwebchannel.js
)
```
就可以把它引入进来了。话不多说，接下来咱们让QML和HTML能顺利握手。

5.QML与HTML交互

接下来先修改test.html文件，监听接收QML的消息以及把表单数据发送QML。

```html
<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <title>登录页面</title>
    <style>
        /* 添加一些基本的样式 */
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f4f4;
        }
        form {
            background-color: #fff;
            padding: 20px;
            margin: 20px auto;
            max-width: 500px;
            box-shadow: 0 0 10px rgba(0, 0, 0, 0.2);
        }
        label {
            display: block;
            margin-bottom: 10px;
        }
        input[type="text"],
        input[type="password"] {
            display: block;
            width: 100%;
            padding: 10px;
            margin-bottom: 20px;
            border: 1px solid #ccc;
            border-radius: 4px;
            box-sizing: border-box;
        }
        button[type="submit"] {
            background-color: #4CAF50;
            color: #fff;
            padding: 10px 20px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        button[type="submit"]:hover {
            background-color: #3e8e41;
        }
    </style>

    <script src="qwebchannel.js"></script> 
    <script>
        var qtJS;

        document.addEventListener("DOMContentLoaded", function() {
            new QWebChannel(qt.webChannelTransport, function(channel) {
                qtJS = channel.objects.QTJS;

                // 监听来自 QML 的验证结果
                qtJS.callhtml.connect(function(func, args) {
                    console.log("收到 callhtml 信号:", func, args);

                    if (func === "receiveValidationResult") {
                        // 根据验证结果进行处理
                        if (args === "验证成功") {
                            alert("登录成功！");
                        } else if (args === "验证失败") {
                            alert("用户名或密码错误！");
                        }
                    }
                });
            });
        });

        // 处理表单提交
        function handleFormSubmit(event) {
            event.preventDefault(); // 防止默认的表单提交行为

            // 获取表单数据
            var username = document.getElementById("username").value;
            var password = document.getElementById("password").value;

            // 将数据发送给 QML
            if (qtJS) {
                qtJS.receiveLoginData(username, password);
            }
        }

        // 绑定表单提交事件
        document.addEventListener("DOMContentLoaded", function() {
            var form = document.querySelector("form");
            form.addEventListener("submit", handleFormSubmit);
        });
    </script>
</head>
<body>
    <form>
        <h1>登录</h1>
        <label for="username">用户名:</label>
        <input type="text" id="username" name="username">

        <label for="password">密码:</label>
        <input type="password" id="password" name="password">

        <button type="submit">登录</button>
    </form>
</body>
</html>

```
然后再项目根目录新建一个 webChFunc.js（注意要加到cmake）
这时候的CMakeLists.txt应该是这样：
```
qt_add_qml_module(appQT-Vue
    URI QT-Vue
    VERSION 1.0
    QML_FILES
        Main.qml
        RESOURCES test.html
        QML_FILES qwebchannel.js
        QML_FILES webChFunc.js
)
```

![image.png](/static/img/ba2abdedc5692db291f92f7eaf5975aa.image.webp)
接下来修改webChFunc.js
```JavaScript
// webChFunc.js

// 定义一个对象，用于存放所有可供调用的函数
var nameToFunc = {
    exampleFunction: function(args) {
        console.log("exampleFunction 被调用，参数为:", args);
     },
    anotherFunction: function(args) {
        console.log("anotherFunction 被调用，参数为:", args);
     }
};

// 将 nameToFunc 对象暴露给 QML 使用
Qt.include("webChFunc.js");

```

最后再来修改Main.qml，接收JS传来的消息并把处理结果反馈回去
```
import QtQuick 2.15
import QtWebEngine 1.15
import QtWebChannel 1.15
import "webChFunc.js" as WebChFunc

Window {
    width: 640
    height: 480
    visible: true
    title: qsTr("登录示例")

    QtObject {
        id: qtJS
        WebChannel.id: "QTJS"

        // 信号：从 QML 调用 HTML 的函数
        signal callhtml(string func, string args)

        // 函数：从 HTML 调用，用于路由消息到相应的 QML 函数
        function callqml(func, args) {
            if (WebChFunc.nameToFunc[func]) {
                WebChFunc.nameToFunc[func](args);
            } else {
                console.warn("没有注册名为", func, "的函数。");
            }
        }

        // 函数：向 JavaScript 发送信号
        function sendSignalToJS(result) {
            callhtml("receiveValidationResult", result);
        }

        // 暴露给 JavaScript 调用的函数，用于接收来自 JS 的消息
        function receiveFromJS(message) {
            console.log("收到来自 JS 的消息:", message);
            // 你可以在这里基于接收到的消息调用某些 QML 函数或发出信号
        }

        // 接收来自 HTML 的登录数据
        function receiveLoginData(username, password) {
            console.log("收到登录数据 - 用户名:", username, "密码:", password);
            // 验证用户名和密码
            if (username === "admin" && password === "admin") {
                sendSignalToJS("验证成功");
            } else {
                sendSignalToJS("验证失败");
            }
        }
    }

    WebChannel {
        id: webch
        registeredObjects: [qtJS]
    }

    WebEngineView {
        id: webview
        anchors.fill: parent
        webChannel: webch
        url: Qt.resolvedUrl("test.html")
    }
}

```
编译运行，不出意外，这个时候QML和HTML应该是握手成功了。
让咱们来看看效果，直接点击登录按钮，这个时候JS发送空账号和密码到QML，QML处理后把结果发回来到JS。

![image.png](/static/img/eaf18bb6cf9934b01e6364e55868bf99.image.webp)

在QML中设定的账号和密码都是admin，继续来输入看看结果。

![image.png](/static/img/9eb592d4f0338259f178e319c46c8ebf.image.webp)

一切按照咱们想象的方向发展。
当然，逻辑处理应该放到C++代码来处理而不QML中，让咱们继续来完善一下。
首先创建一个 C++ 类 Authenticator 处理登录逻辑：

![image.png](/static/img/7face39e167cc8a239006524c24e5542.image.webp)


接着修改authenticator.h文件
```C++
#ifndef AUTHENTICATOR_H
#define AUTHENTICATOR_H

#include <QObject>

class Authenticator : public QObject
{
    Q_OBJECT
public:
    explicit Authenticator(QObject *parent = nullptr);

    // QML中可调用的方法，用于接收登录数据
    Q_INVOKABLE void verifyLogin(const QString &username, const QString &password);

signals:
    // 信号：发送验证结果给JS
    void validationResult(const QString &result);

private:
    bool isValidCredentials(const QString &username, const QString &password);
};

#endif // AUTHENTICATOR_H

```

修改authenticator.cpp文件

```C++
#include "Authenticator.h"
#include <QDebug>

Authenticator::Authenticator(QObject *parent) : QObject(parent)
{
}

void Authenticator::verifyLogin(const QString &username, const QString &password)
{
    qDebug() << "Authenticator对象收到登录数据 - 用户名:" << username << "密码:" << password;
    // 验证用户名和密码
    if (isValidCredentials(username, password)) {
        qDebug() << "验证成功，发送消息到QML";
        emit validationResult("验证成功");
    } else {
        qDebug() << "验证失败，发送消息到QML";
        emit validationResult("验证失败");
    }
}

bool Authenticator::isValidCredentials(const QString &username, const QString &password)
{
    // 简单的用户名密码验证逻辑
    return (username == "admin" && password == "admin");
}

```


修改main.cpp

```C++
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include "Authenticator.h"

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);

    QQmlApplicationEngine engine;

    // 创建 Authenticator 实例
    Authenticator authenticator;

    // 将 Authenticator 对象注册为 QML 上下文属性
    engine.rootContext()->setContextProperty("authenticator", &authenticator);

    QObject::connect(
        &engine,
        &QQmlApplicationEngine::objectCreationFailed,
        &app,
        []() { QCoreApplication::exit(-1); },
        Qt::QueuedConnection);

    engine.loadFromModule("QT-Vue", "Main");

    return app.exec();
}

```

最后再来修改Main.qml文件
```
import QtQuick 2.15
import QtWebEngine 1.15
import QtWebChannel 1.15
import "webChFunc.js" as WebChFunc

Window {
    width: 640
    height: 480
    visible: true
    title: qsTr("登录示例")

    QtObject {
        id: qtJS
        WebChannel.id: "QTJS"

        // 信号：从 QML 调用 HTML 的函数
        signal callhtml(string func, string args)

        // 函数：从 HTML 调用，用于路由消息到相应的 QML 函数
        function callqml(func, args) {
            if (WebChFunc.nameToFunc[func]) {
                WebChFunc.nameToFunc[func](args);
            } else {
                console.warn("没有注册名为", func, "的函数。");
            }
        }

        // 函数：向 JavaScript 发送信号
        function sendSignalToJS(result) {
            callhtml("receiveValidationResult", result);
        }

        // 暴露给 JavaScript 调用的函数，用于接收来自 JS 的消息
        function receiveFromJS(message) {
            console.log("收到来自 JS 的消息:", message);
            // 你可以在这里基于接收到的消息调用某些 QML 函数或发出信号
        }

        // 接收来自 HTML 的登录数据
        function receiveLoginData(username, password) {
            console.log("收到登录数据 - 用户名:", username, "密码:", password,"调用C++的验证函数");
             // 调用 C++ 的验证函数
            authenticator.verifyLogin(username, password);
        }
    }

    WebChannel {
        id: webch
        registeredObjects: [qtJS]
    }

    WebEngineView {
        id: webview
        anchors.fill: parent
        webChannel: webch
        url: Qt.resolvedUrl("test.html")
    }

    Component.onCompleted: {
        // 连接 C++ 信号到 QML 信号
        // authenticator.validationResult.connect(qtJS.sendSignalToJS)
        authenticator.validationResult.connect(logOut.logout)

    }
    QtObject {
        id: logOut

         function logout(data){
             console.log("接收到消息：",data,"调用sendSignalToJS函数")
             qtJS.sendSignalToJS(data)
         }
    }
}

```
重新编译运行，看到log输出QML与C++连接起来了。

![image.png](/static/img/2ad93160c337315fe8a5d1038f27b50e.image.webp)
# QT融合Vue


占坑，有空再埋。

QT+Web打造美化的桌面端APP

# FFmpe读取UVC摄像头推流

摄像头是USB免驱摄像头，Go搭建RTSP服务器，ffmpeg命令行工具推流。


用go启动一个rtsp服务器：

```go

package main

import (
    "github.com/bluenviron/gortsplib/v4"
    "log"
    "sync"

    "github.com/pion/rtp"

    "github.com/bluenviron/gortsplib/v4/pkg/base"
    "github.com/bluenviron/gortsplib/v4/pkg/description"
    "github.com/bluenviron/gortsplib/v4/pkg/format"
)

// This example shows how to
// 1. create a RTSP server which accepts plain connections
// 2. allow a single client to publish a stream with TCP or UDP
// 3. allow multiple clients to read that stream with TCP, UDP or UDP-multicast

type serverHandler struct {
    s         *gortsplib.Server
    mutex     sync.Mutex
    stream    *gortsplib.ServerStream
    publisher *gortsplib.ServerSession
}

// called when a connection is opened.
func (sh *serverHandler) OnConnOpen(ctx *gortsplib.ServerHandlerOnConnOpenCtx) {
    log.Printf("conn opened")
}

// called when a connection is closed.
func (sh *serverHandler) OnConnClose(ctx *gortsplib.ServerHandlerOnConnCloseCtx) {
    log.Printf("conn closed (%v)", ctx.Error)
}

// called when a session is opened.
func (sh *serverHandler) OnSessionOpen(ctx *gortsplib.ServerHandlerOnSessionOpenCtx) {
    log.Printf("session opened")
}

// called when a session is closed.
func (sh *serverHandler) OnSessionClose(ctx *gortsplib.ServerHandlerOnSessionCloseCtx) {
    log.Printf("session closed")

    sh.mutex.Lock()
    defer sh.mutex.Unlock()

    // if the session is the publisher,
    // close the stream and disconnect any reader.
    if sh.stream != nil && ctx.Session == sh.publisher {
       sh.stream.Close()
       sh.stream = nil
    }
}

// called when receiving a DESCRIBE request.
func (sh *serverHandler) OnDescribe(ctx *gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
    log.Printf("describe request")

    sh.mutex.Lock()
    defer sh.mutex.Unlock()

    // no one is publishing yet
    if sh.stream == nil {
       return &base.Response{
          StatusCode: base.StatusNotFound,
       }, nil, nil
    }

    // send medias that are being published to the client
    return &base.Response{
       StatusCode: base.StatusOK,
    }, sh.stream, nil
}

// called when receiving an ANNOUNCE request.
func (sh *serverHandler) OnAnnounce(ctx *gortsplib.ServerHandlerOnAnnounceCtx) (*base.Response, error) {
    log.Printf("announce request")

    sh.mutex.Lock()
    defer sh.mutex.Unlock()

    // disconnect existing publisher
    if sh.stream != nil {
       sh.stream.Close()
       sh.publisher.Close()
    }

    // create the stream and save the publisher
    sh.stream = gortsplib.NewServerStream(sh.s, ctx.Description)
    sh.publisher = ctx.Session

    return &base.Response{
       StatusCode: base.StatusOK,
    }, nil
}

// called when receiving a SETUP request.
func (sh *serverHandler) OnSetup(ctx *gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
    log.Printf("setup request")

    // no one is publishing yet
    if sh.stream == nil {
       return &base.Response{
          StatusCode: base.StatusNotFound,
       }, nil, nil
    }

    return &base.Response{
       StatusCode: base.StatusOK,
    }, sh.stream, nil
}

// called when receiving a PLAY request.
func (sh *serverHandler) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
    log.Printf("play request")

    return &base.Response{
       StatusCode: base.StatusOK,
    }, nil
}

// called when receiving a RECORD request.
func (sh *serverHandler) OnRecord(ctx *gortsplib.ServerHandlerOnRecordCtx) (*base.Response, error) {
    log.Printf("record request")

    // called when receiving a RTP packet
    ctx.Session.OnPacketRTPAny(func(medi *description.Media, forma format.Format, pkt *rtp.Packet) {
       // route the RTP packet to all readers
       sh.stream.WritePacketRTP(medi, pkt)
    })

    return &base.Response{
       StatusCode: base.StatusOK,
    }, nil
}

func main() {
    // configure the server
    h := &serverHandler{}
    h.s = &gortsplib.Server{
       Handler:           h,
       RTSPAddress:       ":8554",
       UDPRTPAddress:     ":8000",
       UDPRTCPAddress:    ":8001",
       MulticastIPRange:  "224.1.0.0/16",
       MulticastRTPPort:  8002,
       MulticastRTCPPort: 8003,
    }

    // start server and wait until a fatal error
    log.Printf("server is ready")
    panic(h.s.StartAndWait())
}
```

查看摄像头支持的输入格式：

```shell
v4l2-ctl -d /dev/video0 --list-formats-ext
```



推流命令：
```shell
ffmpeg -f v4l2 -input_format mjpeg -i /dev/video0 -vcodec libx264 -tune zerolatency -preset ultrafast -f rtsp rtsp://192.168.129.191:8554/live.sdp
```

可以通过fflay命令行工具或者vlc播放器播放
```shell
ffplay  rtsp://192.168.129.191:8554/live.sdp
```

FFmpe读取UVC摄像头推流

C++与Go系列之内存篇





### C++ 内存管理

C++ 提供了丰富的内存管理功能，从手动内存管理到自动内存管理都有涉及。

#### 手动内存管理

1. **动态内存分配**
   - `new` 和 `delete`：用于分配和释放单个对象。
     ```cpp
     int* ptr = new int; // 分配一个int
     delete ptr; // 释放内存
     ```
   - `new[]` 和 `delete[]`：用于分配和释放数组。
     ```cpp
     int* arr = new int[10]; // 分配一个int数组
     delete[] arr; // 释放内存
     ```

2. **C风格的内存管理函数**
   - **`malloc`**：分配指定字节数的内存，但不会初始化内存。
     ```cpp
     #include <cstdlib>

     int* ptr = (int*)malloc(sizeof(int) * 10); // 分配一个包含10个int的数组
     if (ptr == NULL) {
         // 处理分配失败的情况
     }

     // 使用内存

     free(ptr); // 释放内存
     ```
   - **`calloc`**：分配指定数量的元素并初始化为零。
     ```cpp
     int* ptr = (int*)calloc(10, sizeof(int)); // 分配并初始化包含10个int的数组
     if (ptr == NULL) {
         // 处理分配失败的情况
     }

     // 使用内存

     free(ptr); // 释放内存
     ```
   - **`realloc`**：重新分配内存大小。
     ```cpp
     int* ptr = (int*)malloc(sizeof(int) * 10); // 分配一个包含10个int的数组
     if (ptr == NULL) {
         // 处理分配失败的情况
     }

     ptr = (int*)realloc(ptr, sizeof(int) * 20); // 重新分配大小为20个int的内存
     if (ptr == NULL) {
         // 处理重新分配失败的情况
     }

     // 使用内存

     free(ptr); // 释放内存
     ```

3. **内存泄漏**
   - 未能释放分配的内存会导致内存泄漏。
   - 使用工具（如Valgrind）检测和调试内存泄漏。

#### 自动内存管理

1. **智能指针**
   - **`std::unique_ptr`**：独占所有权的智能指针，内存会在指针销毁时自动释放。
     ```cpp
     std::unique_ptr<int> ptr(new int(10));
     ```
   - **`std::shared_ptr`**：共享所有权的智能指针，引用计数为零时释放内存。
     ```cpp
     std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
     std::shared_ptr<int> ptr2 = ptr1; // 共享内存
     ```
   - **`std::weak_ptr`**：不增加引用计数的智能指针，用于打破循环引用。
     ```cpp
     std::weak_ptr<int> weakPtr = ptr1;
     ```

2. **RAII（资源获取即初始化）**
   - 通过构造函数获取资源（如内存），通过析构函数释放资源。
   - 标准库中的容器（如`std::vector`）使用RAII管理内存。

---

### Go 内存管理

Go语言提供了自动化的内存管理，主要依赖于垃圾回收（Garbage Collection）。

#### 垃圾回收

1. **自动内存管理**
   - Go语言中的内存分配和释放由垃圾回收器自动处理，开发者无需手动管理内存。
   - 使用`new`或`make`函数分配内存。
     ```go
     ptr := new(int) // 分配一个int
     arr := make([]int, 10) // 分配一个int数组
     ```

2. **垃圾回收器**
   - Go的垃圾回收器采用并发标记-清除算法。
   - 垃圾回收的触发和执行由运行时自动管理，开发者可以通过调整环境变量（如`GOGC`）来影响垃圾回收的频率。
     ```go
     runtime.GC() // 手动触发垃圾回收
     ```

#### 内存泄漏和优化

1. **内存泄漏**
   - 虽然Go有垃圾回收，但依然可能出现内存泄漏，例如长时间持有大对象的引用。
   - 使用`pprof`工具分析和调试内存使用。
     ```go
     import (
         "runtime/pprof"
         "os"
     )

     func main() {
         f, _ := os.Create("memprofile")
         pprof.WriteHeapProfile(f)
         f.Close()
     }
     ```

2. **内存优化**
   - 避免不必要的内存分配和复制。
   - 使用池化技术（如`sync.Pool`）重用对象，减少垃圾回收压力。
     ```go
     var pool = sync.Pool{
         New: func() interface{} {
             return new(bytes.Buffer)
         },
     }

     buf := pool.Get().(*bytes.Buffer)
     buf.Reset()
     pool.Put(buf)
     ```

---

### 对比与总结

1. **手动 vs 自动**
   - C++需要手动管理内存，提供了强大的灵活性，但也增加了内存泄漏和错误的风险。
   - Go采用自动垃圾回收，简化了内存管理，但可能带来性能开销。

2. **工具与调试**
   - C++依赖于工具（如`Valgrind`）检测内存问题。
   - Go使用内置工具（如`pprof`）进行内存分析和优化。

3. **内存优化策略**
   - C++可以通过优化内存分配和使用智能指针来减少内存问题。
   - Go通过调整垃圾回收参数和使用对象池来优化内存使用。

总结来说，C++和Go在内存管理方面各有优劣，选择合适的内存管理方法需要根据具体的应用场景和需求来决定。

C++与Go系列(三)

C++与Go系列之编译篇

Linux系统下自带C++编译工具g++，而Go的编译工具需要安装。



**写在前面**

1.Ubuntu安装最新版本的稳定版 golang-go 可以通过 snap
`sudo snap install go --classic`

如果snap不存在，通过以下命令安装进行按照：`sudo apt install snapd`

如果要查看snap支持安装的版本：`snap info go`


2.Ubuntu安装最新版本的golang-go也可以通过PPA，需要先添加PPA源
`sudo add-apt-repository ppa:longsleep/golang-backports` 

然后执行安装命令
`sudo apt-get install golang-go`

如果要安装指定版本`sudo apt-get install golang-1.11-go`

如果add-apt-repository不存在，通过以下命令安装进行按照：`sudo apt-get install software-properties-common`

如果要查看支持安装的版本：`apt-cache madison golang-go`

3.一般安装完go后还需要设置模块包代理地址：
`go env -w GOPROXY=https://goproxy.cn,direct`
查看是否设置成功：
`go env | grep GOPROXY`

### C++ 代码编译与构建过程

1. **源文件编写**
   - C++源文件通常以`.cpp`、`.h`、`.hpp`等扩展名保存。

2. **预处理（Preprocessing）**
   - 预处理器指令（如`#include`、`#define`）在这一阶段处理。
   - 预处理的输出是一个纯文本文件，没有预处理器指令。

3. **编译（Compilation）**
   - 将预处理后的代码转换为汇编代码。
   - 每个源文件都会生成一个对应的汇编文件（`.s`）。

4. **汇编（Assembly）**
   - 汇编代码转换为机器码，生成目标文件（`.o`或`.obj`）。
   - 目标文件包含二进制代码，但还不是可执行文件。

5. **链接（Linking）**
   - 将所有目标文件和所需的库文件链接在一起，生成最终的可执行文件。
   - 静态链接：将所有依赖的库静态嵌入可执行文件。
   - 动态链接：将依赖库在运行时动态加载。

6. **构建系统**
   - 使用构建系统（如Make、CMake、Ninja）来管理和自动化编译与链接过程。

### Go 代码编译与构建过程

1. **源文件编写**
   - Go源文件以`.go`扩展名保存。

2. **导入包（Importing Packages）**
   - `import`语句用于导入标准库或第三方库。

3. **编译（Compilation）**
   - Go编译器将所有的Go文件编译成中间代码。
   - 所有依赖包在编译时会被解析和编译。

4. **链接（Linking）**
   - 将所有中间代码和所需的库链接成一个单一的可执行文件。
   - Go使用静态链接，所有依赖库都嵌入到可执行文件中。

5. **构建工具**
   - Go有内置的构建工具，如`go build`、`go install`、`go run`。
   - `go build`：编译包及其依赖项，但不安装结果。
   - `go install`：编译并安装包。
   - `go run`：编译并运行Go程序。

### 对比总结

1. **编译过程**
   - C++有多个独立的阶段（预处理、编译、汇编、链接），而Go的编译过程更简化，直接从源码到可执行文件。
   
2. **构建系统**
   - C++常用第三方构建系统，如Make、CMake，Go则使用内置工具，简化了构建过程。当然，Make也可以用于构建Go项目
   
3. **依赖管理**
   - C++的依赖管理通常通过手动配置或使用包管理器（如vcpkg、Conan）。
   - Go有内置的模块管理系统（Go Modules），方便依赖管理。

### 示例代码与命令

**C++ 构建示例**
```cpp
// main.cpp
#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}
```
```bash
g++ -o hello main.cpp
./hello
```

**Go 构建示例**
```go
// main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}
```
```bash
go build -o hello main.go
./hello
```

编译后的文件比对(编译器版本不同可能编译出来的大小不一样)，其hello_cpp采用动态链接libstdc++.so：

```
root@ubuntu:~/cpp-go# ls -alh
total 1.9M
drwxr-xr-x 2 root root 4.0K Jul 21 10:19 .
drwxr-xr-x 6 root root 4.0K Jul 20 23:07 ..
-rwxr-xr-x 1 root root 9.7K Jul 20 23:08 hello_cpp
-rw-r--r-- 1 root root   97 Jul 20 23:07 hello_cpp.cpp
-rwxr-xr-x 1 root root 1.9M Jul 21 10:19 hello_go
-rw-r--r-- 1 root root   77 Jul 20 23:07 hello_go.go
```

### 关于交叉编译

交叉编译（Cross-compilation）是指在一种平台上编译生成可在另一种平台上运行的二进制文件的过程。也就是说，在Linux上编译生成Windows的程序，或者在x86_64架构的Linux上编译生成适用于ARM64架构的Linux程序，都是要通过交叉编译。

#### C++交叉编译

##### 工具链

C++交叉编译通常需要特定的工具链，例如`gcc`、`g++`的交叉编译版本。常见的工具链有：

- `arm-linux-gnueabi-g++`：用于ARM架构的Linux系统。
- `x86_64-w64-mingw32-g++`：用于64位的Windows系统。

##### 示例：在Linux上为ARM编译


```bash
arm-linux-gnueabi-g++ -o hello_arm main.cpp
```

如果还没有安装ARM交叉编译工具链，可以使用以下命令进行安装：

```bash
sudo apt-get install g++-arm-linux-gnueabi
```

##### 示例：在Linux上为Windows编译



```bash
x86_64-w64-mingw32-g++ -o hello_windows.exe main.cpp
```

如果还没有安装Windows交叉编译工具链，可以使用以下命令进行安装：

```bash
sudo apt-get install g++-mingw-w64
```

#### Go交叉编译

Go语言的交叉编译比C++要简单得多，因为Go编译器本身就支持多平台交叉编译。

##### 设置环境变量

在Go中进行交叉编译，只需设置几个环境变量：

- `GOOS`：目标操作系统，如`linux`、`windows`、`darwin`。
- `GOARCH`：目标架构，如`amd64`、`arm`、`386`。

##### 示例：在Linux上为Windows编译



```bash
GOOS=windows GOARCH=amd64 go build -o hello_windows.exe main.go
```

##### 示例：在Linux上为ARM编译


```bash
GOOS=linux GOARCH=arm go build -o hello_arm main.go
```

#### 对比与总结

1. **工具链**
   - C++需要特定的交叉编译工具链，如`arm-linux-gnueabi-g++`、`x86_64-w64-mingw32-g++`。
   - Go内置支持交叉编译，只需设置环境变量`GOOS`和`GOARCH`。

2. **编译命令**
   - C++需要安装并使用对应的交叉编译器。
   - Go通过内置支持，直接设置环境变量即可实现交叉编译。

3. **配置简易性**
   - C++的交叉编译配置相对复杂，需要了解并配置对应的工具链。
   - Go的交叉编译配置简单，编译过程更为直观。