ffmpeg 摄像头推流

您好！要使用FFmpeg推流摄像头视频流，您可以使用以下命令：

ffmpeg -f v4l2 -input_format h264 -i /dev/video0 -c:v copy -f flv rtmp://server/live/stream_name

这个命令假设您的摄像头设备在`/dev/video0`上。您可以根据实际情况更改设备路径。

请注意，上述命令中的`rtmp://server/live/stream_name`是流媒体服务器的地址和流名称。您需要将其替换为您自己的服务器地址和流名称。

此命令将以H264格式从摄像头读取视频流，并将其复制到RTMP流。如果您希望对视频进行编码，请使用适当的视频编码器选项。

相关问题

ubuntu ffmpeg摄像头推流

要在Ubuntu上使用ffmpeg推流摄像头视频，您可以按照以下步骤进行操作：

1. 首先，安装yasm和ffmpeg。您可以使用以下命令来安装它们：

wget http://www.tortall.net/projects/yasm/releases/yasm-1.3.0.tar.gz
tar zxvf yasm-1.3.0.tar.gz
cd yasm-1.3.0/
./configure
make && sudo make install

wget https://ffmpeg.org/releases/ffmpeg-3.4.6.tar.gz
tar zxvf ffmpeg-3.4.6.tar.gz
cd ffmpeg-3.4.6/
./configure --prefix=/usr/local --enable-shared --enable-static
make && sudo make install

这将下载并安装yasm和ffmpeg。

2. 修改ld.so.conf和etc/profile文件，以便系统能够找到ffmpeg库。您可以使用以下命令进行编辑：

sudo vi /etc/ld.so.conf

在文件中添加以下行：

/usr/local/ffmpeg

保存并关闭文件。

3. 验证ffmpeg是否成功安装。您可以使用以下命令检查ffmpeg和ffserver的版本：

ffmpeg -version
ffserver -version

如果成功安装，将显示ffmpeg和ffserver的版本信息。

4. 运行ffserver以启动流媒体服务器。您可以使用以下命令运行ffserver：

ffserver -f ffserver.conf

这将使用名为ffserver.conf的配置文件启动ffserver。

5. 推流摄像头视频。您可以使用以下命令将摄像头视频推流到指定的URL：

ffmpeg -i /dev/video0 http://X.X.X.X:port/feed1.ffm

其中，/dev/video0是摄像头设备的路径，X.X.X.X是服务器的IP地址，port是端口号。

6. 拉流视频。您可以在VLC或浏览器中使用以下URL来拉取视频流：

http://X.X.X.X:port/test.webm

其中，X.X.X.X是服务器的IP地址，port是端口号。

请注意，您需要根据您的实际情况修改命令中的IP地址、端口号和设备路径。
#### 引用[.reference_title]
- *1* *2* *3* [FFmpeg在ubuntu18.04平台安装和推流demo](https://blog.csdn.net/m0_37400316/article/details/107207271)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]

LINUX C++ ffmpeg 摄像头 推流 代码示例

这里提供一个简单的示例代码，使用FFmpeg推送摄像头采集到的视频流：

#include <iostream>
#include <thread>
#include <chrono>
#include <opencv2/opencv.hpp>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

using namespace std;
using namespace cv;

int main(int argc, char* argv[])
{
    // 打开摄像头
    VideoCapture cap(0);
    if (!cap.isOpened())
    {
        cerr << "Failed to open camera!" << endl;
        return -1;
    }

    // 初始化FFmpeg
    av_register_all();
    avformat_network_init();

    // 创建输出上下文
    AVFormatContext* outctx = nullptr;
    if (avformat_alloc_output_context2(&outctx, nullptr, "flv", "rtmp://localhost/live/test") < 0)
    {
        cerr << "Failed to create output context!" << endl;
        return -1;
    }

    // 添加视频流
    AVCodecID codec_id = AV_CODEC_ID_H264;
    AVCodec* codec = avcodec_find_encoder(codec_id);
    if (!codec)
    {
        cerr << "Failed to find encoder!" << endl;
        return -1;
    }
    AVStream* outstream = avformat_new_stream(outctx, codec);
    if (!outstream)
    {
        cerr << "Failed to create stream!" << endl;
        return -1;
    }
    outstream->codecpar->codec_id = codec_id;
    outstream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
    outstream->codecpar->width = cap.get(CV_CAP_PROP_FRAME_WIDTH);
    outstream->codecpar->height = cap.get(CV_CAP_PROP_FRAME_HEIGHT);
    outstream->codecpar->format = AV_PIX_FMT_YUV420P;

    // 打开编码器
    if (avcodec_open2(outstream->codec, codec, nullptr) < 0)
    {
        cerr << "Failed to open encoder!" << endl;
        return -1;
    }

    // 打开输出流
    if (!(outctx->oformat->flags & AVFMT_NOFILE))
    {
        if (avio_open(&outctx->pb, outctx->url, AVIO_FLAG_WRITE) < 0)
        {
            cerr << "Failed to open output stream!" << endl;
            return -1;
        }
    }

    // 写文件头
    if (avformat_write_header(outctx, nullptr) < 0)
    {
        cerr << "Failed to write header!" << endl;
        return -1;
    }

    // 初始化图像转换器
    SwsContext* swsctx = sws_getContext(cap.get(CV_CAP_PROP_FRAME_WIDTH), cap.get(CV_CAP_PROP_FRAME_HEIGHT), AV_PIX_FMT_BGR24,
        outstream->codecpar->width, outstream->codecpar->height, outstream->codecpar->format, SWS_BICUBIC, nullptr, nullptr, nullptr);
    if (!swsctx)
    {
        cerr << "Failed to create image converter!" << endl;
        return -1;
    }

    // 循环读取视频帧并推送
    Mat frame;
    AVFrame* avframe = av_frame_alloc();
    avframe->format = outstream->codecpar->format;
    avframe->width = outstream->codecpar->width;
    avframe->height = outstream->codecpar->height;
    av_frame_get_buffer(avframe, 32);
    while (true)
    {
        cap >> frame;
        if (frame.empty())
            break;

        // 转换图像格式
        uint8_t* data[AV_NUM_DATA_POINTERS] = { 0 };
        data[0] = frame.data;
        int linesize[AV_NUM_DATA_POINTERS] = { 0 };
        linesize[0] = frame.step;
        sws_scale(swsctx, data, linesize, 0, frame.rows, avframe->data, avframe->linesize);

        // 编码并发送视频帧
        AVPacket pkt = { 0 };
        av_init_packet(&pkt);
        int ret = avcodec_send_frame(outstream->codec, avframe);
        if (ret < 0)
        {
            cerr << "Failed to send frame!" << endl;
            break;
        }
        while (ret >= 0)
        {
            ret = avcodec_receive_packet(outstream->codec, &pkt);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                break;
            else if (ret < 0)
            {
                cerr << "Error while encoding frame!" << endl;
                break;
            }

            // 发送数据包
            av_packet_rescale_ts(&pkt, outstream->codec->time_base, outstream->time_base);
            pkt.stream_index = outstream->index;
            ret = av_interleaved_write_frame(outctx, &pkt);
            if (ret < 0)
                cerr << "Failed to write packet!" << endl;
            av_packet_unref(&pkt);
        }

        // 等待一段时间
        this_thread::sleep_for(chrono::milliseconds(30));
    }

    // 写文件尾
    av_write_trailer(outctx);

    // 释放资源
    avcodec_close(outstream->codec);
    avcodec_free_context(&outstream->codec);
    avformat_free_context(outctx);
    av_frame_free(&avframe);
    sws_freeContext(swsctx);

    return 0;
}

请注意修改代码中的推流地址和编码器参数，以适应你的需求。