c++调用ffmpeg api录屏 并进行rtmp推流

最新推荐文章于 2024-04-23 22:55:47 发布
最新推荐文章于 2024-04-23 22:55:47 发布
阅读量1.2k 收藏 2
点赞数 1
文章标签： c++ ffmpeg api 录屏 推流 rtmp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daqinzl/article/details/132080342
版权

代码及工程见https://download.csdn.net/download/daqinzl/88156528

开发工具：visual studio 2019

记得启动rtmp流媒体服务 nginx的rtmp服务见https://download.csdn.net/download/daqinzl/20478812

播放，采用ffmpeg工具集里的ffplay.exe, 执行命令 ffplay rtmp://192.168.0.105:1935/live/desktop

主要代码如下:


#include "pch.h"
#include <iostream>
using namespace std;

#include <stdio.h>

#define __STDC_CONSTANT_MACROS

extern "C"
{
#include "include/libavcodec/avcodec.h"
#include "include/libavformat/avformat.h"
#include "include/libswscale/swscale.h"
#include "include/libavdevice/avdevice.h"
#include "include/libavutil/imgutils.h"
#include "include/libavutil/opt.h"
#include "include/libavutil/imgutils.h"
#include "include/libavutil/mathematics.h"
#include "include/libavutil/time.h"
};


#pragma comment (lib,"avcodec.lib")
#pragma comment (lib,"avdevice.lib")
#pragma comment (lib,"avfilter.lib")
#pragma comment (lib,"avformat.lib")
#pragma comment (lib,"avutil.lib")
#pragma comment (lib,"swresample.lib")
#pragma comment (lib,"swscale.lib")


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

            AVFormatContext* m_fmt_ctx = NULL;
        AVInputFormat* m_input_fmt = NULL;
        int video_stream = -1;
        avdevice_register_all();
        avcodec_register_all();
        const char* deviceName =  "desktop";
        const char* inputformat = "gdigrab";
        int FPS = 23;  //15
        m_fmt_ctx = avformat_alloc_context();
        m_input_fmt = av_find_input_format(inputformat);
        AVDictionary* deoptions = NULL;
        av_dict_set_int(&deoptions, "framerate", FPS, AV_DICT_MATCH_CASE);
        av_dict_set_int(&deoptions, "rtbufsize", 3041280 * 100 * 5, 0);
        int ret = avformat_open_input(&m_fmt_ctx, deviceName, m_input_fmt, &deoptions);
        if (ret != 0) {
            
                return ret;
        }
        av_dict_free(&deoptions);
        ret = avformat_find_stream_info(m_fmt_ctx, NULL);
        if (ret < 0) {
            
                return ret;
        }
        av_dump_format(m_fmt_ctx, 0, deviceName, 0);
        video_stream = av_find_best_stream(m_fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
        if (video_stream < 0) {
            
                return -1;
        }

        AVCodecContext * _codec_ctx = m_fmt_ctx->streams[video_stream]->codec;
        AVCodec* _codec = avcodec_find_decoder(_codec_ctx->codec_id);
        if (_codec == NULL) {
            
                return -1;
        }
        ret = avcodec_open2(_codec_ctx, _codec, NULL);
        if (ret != 0) {
            
                return -1;
        }
        int width = m_fmt_ctx->streams[video_stream]->codec->width;
        int height = m_fmt_ctx->streams[video_stream]->codec->height;
        int fps = m_fmt_ctx->streams[video_stream]->codec->framerate.num > 0 ? m_fmt_ctx->streams[video_stream]->codec->framerate.num : 25;
        AVPixelFormat videoType = m_fmt_ctx->streams[video_stream]->codec->pix_fmt;
        std::cout << "avstream timebase : " << m_fmt_ctx->streams[video_stream]->time_base.num << " / " << m_fmt_ctx->streams[video_stream]->time_base.den << endl;
            AVDictionary* enoptions = 0;
        av_dict_set(&enoptions, "preset", "superfast", 0);
        av_dict_set(&enoptions, "tune", "zerolatency", 0);
        AVCodec* codec = avcodec_find_encoder(AV_CODEC_ID_H264);
        if (!codec)
        {
            
                std::cout << "avcodec_find_encoder failed!" << endl;
            return NULL;
        }
        AVCodecContext* vc = avcodec_alloc_context3(codec);
        if (!vc)
        {
            
                std::cout << "avcodec_alloc_context3 failed!" << endl;
            return NULL;
        }
        std::cout << "avcodec_alloc_context3 success!" << endl;
        vc->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
        vc->codec_id = AV_CODEC_ID_H264;
        vc->codec_type = AVMEDIA_TYPE_VIDEO;
        vc->pix_fmt = AV_PIX_FMT_YUV420P;
        vc->width = width;
        vc->height = height;
        vc->time_base.num = 1;
        vc->time_base.den = FPS;
        vc->framerate = { FPS,1 };
        vc->bit_rate = 10241000;
        vc->gop_size = 120;
        vc->qmin = 10;
        vc->qmax = 51;
        vc->max_b_frames = 0;
        vc->profile = FF_PROFILE_H264_MAIN;
        ret = avcodec_open2(vc, codec, &enoptions);
        if (ret != 0)
        {
            return ret;
        }
        std::cout << "avcodec_open2 success!" << endl;
        av_dict_free(&enoptions);
        SwsContext *vsc = nullptr;
        vsc = sws_getCachedContext(vsc,
            width, height, (AVPixelFormat)videoType, //源宽、高、像素格式
            width, height, AV_PIX_FMT_YUV420P,//目标宽、高、像素格式
            SWS_BICUBIC, // 尺寸变化使用算法
            0, 0, 0
        );
        if (!vsc)
        {
            
                cout << "sws_getCachedContext failed!";
            return false;
        }
        AVFrame* yuv = av_frame_alloc();
        yuv->format = AV_PIX_FMT_YUV420P;
        yuv->width = width;
        yuv->height = height;
        yuv->pts = 0;
        ret = av_frame_get_buffer(yuv, 32);
        if (ret != 0)
        {
            
                return ret;
        }
        const char* rtmpurl = "rtmp://192.168.0.105:1935/live/desktop";
       
        AVFormatContext * ic = NULL;
        ret = avformat_alloc_output_context2(&ic, 0, "flv", rtmpurl);
        if (ret < 0)
        {
            
                return ret;
        }
        AVStream* st = avformat_new_stream(ic, NULL);
        if (!st)
        {
            
                return -1;
        }
        st->codecpar->codec_tag = 0;
        avcodec_parameters_from_context(st->codecpar, vc);
        av_dump_format(ic, 0, rtmpurl, 1);
        ret = avio_open(&ic->pb, rtmpurl, AVIO_FLAG_WRITE);
        if (ret != 0)
        {
            
                return ret;
        }
        ret = avformat_write_header(ic, NULL);
        if (ret != 0)
        {
            
                return ret;
        }
        AVPacket* packet = av_packet_alloc();
        AVPacket* Encodepacket = av_packet_alloc();
        int frameIndex = 0;
        int EncodeIndex = 0;
        AVFrame* rgb = av_frame_alloc();
        AVBitStreamFilterContext* h264bsfc = av_bitstream_filter_init("h264_mp4toannexb");
        long long startpts = m_fmt_ctx->start_time;
        long long lastpts = 0;
        long long duration = av_rescale_q(1, { 1,FPS }, { 1,AV_TIME_BASE });
        int got_picture = 0;
        while (frameIndex < 2000000)
        {
            
                ret = av_read_frame(m_fmt_ctx, packet);
            if (ret < 0) {
                
                    break;
            }
            if (packet->stream_index == video_stream)
            {
                
                    ret = avcodec_decode_video2(_codec_ctx, rgb, &got_picture, packet);
                if (ret < 0) {
                    
                        printf("Decode Error.\n");
                    return ret;
                }
                if (got_picture) {
                    
                        int h = sws_scale(vsc, rgb->data, rgb->linesize, 0, height, //源数据
                            yuv->data, yuv->linesize);
                    int guesspts = frameIndex * duration;
                    yuv->pts = guesspts;
                    frameIndex++;
                    ret = avcodec_encode_video2(vc, Encodepacket, yuv, &got_picture);
                    if (ret < 0) {
                        
                            printf("Failed to encode!\n");
                        break;
                    }
                    if (got_picture == 1) {
                        
                            Encodepacket->pts = av_rescale_q(EncodeIndex, vc->time_base, st->time_base);
                        Encodepacket->dts = Encodepacket->pts;
                        std::cout << "frameindex : " << EncodeIndex << " pts : " << Encodepacket->pts << " dts: " << Encodepacket->dts << " encodeSize:" << Encodepacket->size << " curtime - lasttime " << Encodepacket->pts - lastpts << endl;
                            lastpts = Encodepacket->pts;
                        ret = av_interleaved_write_frame(ic, Encodepacket);
                        EncodeIndex++;
                        av_packet_unref(Encodepacket);
                    }
                }
            }
            av_packet_unref(packet);
        }
        ret = avcodec_send_frame(vc, NULL);
        while (ret >= 0) {
            
                ret = avcodec_receive_packet(vc, Encodepacket);
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                
                    break;
            }
            if (ret < 0) {
                
                    break;
            }
            ret = av_interleaved_write_frame(ic, Encodepacket);
            EncodeIndex++;
        }
        av_write_trailer(ic);
        av_packet_free(&packet);
        av_packet_free(&Encodepacket);
        av_frame_free(&rgb);
        av_frame_free(&yuv);
        av_bitstream_filter_close(h264bsfc);
        h264bsfc = NULL;
        if (vsc)
        {
            
                sws_freeContext(vsc);
            vsc = NULL;
        }
        if (_codec_ctx)
            avcodec_close(_codec_ctx);
        _codec_ctx = NULL;
        _codec = NULL;
        if (vc)
            avcodec_free_context(&vc);
        if (m_fmt_ctx)
            avformat_close_input(&m_fmt_ctx);
        if (ic && !(ic->flags & AVFMT_NOFILE))
            avio_closep(&ic->pb);
        if (ic) {
            
                avformat_free_context(ic);
            ic = NULL;
        }
        m_input_fmt = NULL;
        return 0;
    }
    

daqinzl
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Qt/C++音视频开发20-vlc内核动态保存录像文件（不需要重新编译源码）
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
03-06 1726
在vlc默认提供的保存文件方式中，通过打开的时候传入指定的参数来保存文件，直到关闭播放生成文件，这种方式简单暴力，但是不适用大部分的场景，大部分时候需要的是提供开始录制和停止录制的功能，也就是在播放过程中能够动态录制多个文件，想录制的时候就录制，要结束的时候就结束录制，很遗憾vlc并没有提供这样的函数接口。
VC调用ffmpeg步骤及示例代码
03-29
1.调用方法步骤的TXT说明，内附SDK下载地址 2.自己写的调用FFMPEG将文件Video转为BMP的源码 3.TXT文件说明和源码粘贴，简明清析
Linux 下使用 ffmpeg 屏幕录像的方法
hq2902108007的专栏
05-26 2027
Note: This was the original post not done by me, but i will try to update if anything new comes up Quote: Demo Video http://www.youtube.com/watch?v=Ewxm6T6rXP0 While many screenca
使用 FFmpeg 实现录屏和录音
最新发布
weixin_43978579的博客
04-23 1802
FFmpeg 是一个非常强大的开源工具，可以用来处理音频和视频。可以实现录屏和录音，也可以进行简单的剪辑。
C++ 调用 ffmpeg 进行 rtmp 推流
liveweb视频汇聚平台
06-29 1125
Clion 中演示的效果终端中运行也没有问题。
利用ffmpeg实现rtmp推流直播
热门推荐
gqg_guan的博客
02-21 1万+
ffmpeg直播
FFmpeg常见命令行（四）：FFmpeg流媒体
分享计算机基础，android，C/C++，音视频等内容
08-11 4219
本文是音视频系列blog的其中一个， 对应的要学习的内容是：如何使用FFmpeg命令行进行流媒体的处理。
java语言使用ffmpeg在windows系统中实现视频推流拉流
weixin_42684368的博客
10-25 1897
本文主要详细介绍在windows系统下，采用java语言来实现rtmp流媒体协议的视频的推流拉流。利用screen capturer recorder录屏工具结合ffmpeg.exe文件捕获桌面视频流并推到nginx服务器，随后使用浏览器进行视频流的拉取并播放。文末给出相关工具的下载链接。
c++调用ffmpeg api录屏 并进行udp组播推流
08-03
c++调用ffmpeg api录屏，并以udp组播的形式推流
c++调用ffmpeg api将视频文件内容进行udp组播推流
08-03
本篇文章将深入探讨如何使用C++调用FFmpeg API来实现将视频文件内容通过UDP组播进行推流。 首先，我们需要了解FFmpeg的基本架构。FFmpeg主要包括libavcodec（负责编解码）、libavformat（处理容器格式和流协议）、...
最简单的基于FFmpeg的推流器（以推送RTMP为例） 1.1
02-13
本例子实现了推送本地视频至流媒体服务器（以RTMP为例）。是使用FFmpeg进行流媒体推送最简单的教程。 1.1版本增加了多平台下编译的支持：Windows，MacOS，以及Linux。
非常好用的一个rtmppush_sdk,编解码，rtmp推流
09-28
非常好用的一个rtmppush_sdk,编解码，rtmp推流。。。。
C#开发FFMPEG例子(API方式) FFmpeg拉取RTMP流并播放原始源码
04-15
C#开发FFMPEG例子(API方式) FFmpeg拉取RTMP流并播放原始源码
最简单的基于FFmpeg的推流器（以推送RTMP为例）
03-27
本例子实现了推送本地视频至流媒体服务器（以RTMP为例）。是使用FFmpeg进行流媒体推送最简单的教程。 1.1版本增加了多平台下编译的支持：Windows，MacOS，以及Linux。
基于ffmpeg实现的rtmp推流模块
02-28
需要先创建推流的流媒体地址，然后再创建一个对象启动推流，创建过程如下。 RtmpPublishManager* rpm = new RtmpPublishManager("rtmp://192.168.16.88:1935/hls/test0", read_fd[0]); rpm->ffmpeg_init(NULL); rpm->start();
ffmpeg 编译 支持 h265 rtmp 推流
08-04
在本教程中，我们将详细讲解如何在Windows环境下，使用MSYS2 MinGW 64-bit编译FFmpeg，使其支持H265编码和RTMP推流。 一、安装MSYS2 MinGW 64-bit 1. 首先，从MSYS2官方网站下载最新版本的MSYS2安装程序。 2. 安装...
Qt调用FFmpeg命令录屏
02-25
在本文中，我们将深入探讨如何在Windows平台上使用Qt框架调用FFmpeg命令行工具来实现录屏功能。FFmpeg是一个强大的开源多媒体处理工具，而Qt则是一个跨平台的应用程序开发框架，两者结合可以轻松实现复杂的视频录制...
基于FFmpeg实现屏幕录制
Keep Moving~
07-02 6716
https://trac.ffmpeg.org/wiki/Capture/Desktop https://blog.csdn.net/Fandes_F/article/details/105121581 https://www.cnblogs.com/-yan/p/4759965.html
ffmpeg6.0 录屏并推流到rtmp c++示例
06-07
以下是一个简单的示例代码，展示如何使用FFmpeg 6.0在C++中录屏并将其推流到RTMP服务器： ```cpp #include <iostream> #include <cstdlib> #include <chrono> #include <thread> extern "C" { #include <libavutil/avutil.h> #include <libavutil/opt.h> #include <libavutil/time.h> #include <libavformat/avformat.h> #include <libavcodec/avcodec.h> #include <libswscale/swscale.h> #include <libswresample/swresample.h> #include <libavutil/imgutils.h> #include <X11/Xlib.h> #include <X11/Xutil.h> #include <X11/extensions/XShm.h> } #define STREAM_URL "rtmp://example.com/live/stream" int main() { // Initialize X11 display Display *disp = XOpenDisplay(NULL); if (!disp) { std::cerr << "Error: Could not open X11 display." << std::endl; return EXIT_FAILURE; } int screen = DefaultScreen(disp); Window root = RootWindow(disp, screen); // Get screen dimensions int width = XDisplayWidth(disp, screen); int height = XDisplayHeight(disp, screen); // Create XImage and XShmImage structures XImage *ximg = XGetImage(disp, root, 0, 0, width, height, AllPlanes, ZPixmap); XShmSegmentInfo shminfo; XShmCreateImage(disp, root, ZPixmap, 0, ximg->width, ximg->height, ximg->depth, &shminfo, 0); shminfo.shmaddr = (char *)shmat(shminfo.shmid, 0, 0); shminfo.readOnly = False; XShmAttach(disp, &shminfo); XSync(disp, False); // Allocate AVFrame for video data AVFrame *frame = av_frame_alloc(); if (!frame) { std::cerr << "Error: Could not allocate AVFrame." << std::endl; return EXIT_FAILURE; } frame->width = width; frame->height = height; frame->format = AV_PIX_FMT_RGB24; if (av_frame_get_buffer(frame, 32) < 0) { std::cerr << "Error: Could not allocate video frame data." << std::endl; return EXIT_FAILURE; } // Initialize FFmpeg av_register_all(); avcodec_register_all(); avformat_network_init(); // Open output context AVFormatContext *outctx = nullptr; if (avformat_alloc_output_context2(&outctx, nullptr, "flv", STREAM_URL) < 0) { std::cerr << "Error: Could not allocate output context." << std::endl; return EXIT_FAILURE; } if (avio_open2(&outctx->pb, STREAM_URL, AVIO_FLAG_WRITE, nullptr, nullptr) < 0) { std::cerr << "Error: Could not open output URL." << std::endl; return EXIT_FAILURE; } // Add video stream AVStream *vstream = avformat_new_stream(outctx, nullptr); if (!vstream) { std::cerr << "Error: Could not allocate video stream." << std::endl; return EXIT_FAILURE; } vstream->id = 0; vstream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; vstream->codecpar->codec_id = AV_CODEC_ID_H264; vstream->codecpar->width = width; vstream->codecpar->height = height; vstream->codecpar->format = AV_PIX_FMT_YUV420P; vstream->codecpar->bit_rate = 400000; vstream->codecpar->profile = FF_PROFILE_H264_BASELINE; // Find encoder AVCodec *vcodec = avcodec_find_encoder(vstream->codecpar->codec_id); if (!vcodec) { std::cerr << "Error: Could not find video encoder." << std::endl; return EXIT_FAILURE; } // Open video encoder AVCodecContext *vctx = avcodec_alloc_context3(vcodec); if (!vctx) { std::cerr << "Error: Could not allocate video encoder context." << std::endl; return EXIT_FAILURE; } if (avcodec_parameters_to_context(vctx, vstream->codecpar) < 0) { std::cerr << "Error: Could not initialize video encoder context." << std::endl; return EXIT_FAILURE; } vctx->bit_rate = 400000; vctx->time_base = {1, 25}; vctx->gop_size = 10; if (vstream->codecpar->codec_id == AV_CODEC_ID_H264) { av_opt_set(vctx->priv_data, "preset", "ultrafast", 0); av_opt_set(vctx->priv_data, "tune", "zerolatency", 0); } if (avcodec_open2(vctx, vcodec, nullptr) < 0) { std::cerr << "Error: Could not open video encoder." << std::endl; return EXIT_FAILURE; } // Allocate AVPacket for video data AVPacket *vpacket = av_packet_alloc(); if (!vpacket) { std::cerr << "Error: Could not allocate video packet." << std::endl; return EXIT_FAILURE; } // Allocate AVFrame for video data after conversion to YUV420P AVFrame *vframe = av_frame_alloc(); if (!vframe) { std::cerr << "Error: Could not allocate video frame." << std::endl; return EXIT_FAILURE; } vframe->width = width; vframe->height = height; vframe->format = vctx->pix_fmt; if (av_frame_get_buffer(vframe, 32) < 0) { std::cerr << "Error: Could not allocate video frame data." << std::endl; return EXIT_FAILURE; } // Initialize swscale context for converting RGB to YUV420P SwsContext *swsctx = sws_getContext(width, height, AV_PIX_FMT_RGB24, width, height, vctx->pix_fmt, SWS_BICUBIC, nullptr, nullptr, nullptr); if (!swsctx) { std::cerr << "Error: Could not initialize swscale context." << std::endl; return EXIT_FAILURE; } // Write header to output context avformat_write_header(outctx, nullptr); // Read and encode video frames std::cout << "Start recording." << std::endl; while (true) { // Get screenshot from X11 XShmGetImage(disp, root, ximg, 0, 0, AllPlanes); // Convert RGB to YUV420P sws_scale(swsctx, (const uint8_t * const *)frame->data, frame->linesize, 0, height, vframe->data, vframe->linesize); // Encode video frame vframe->pts = av_rescale_q(av_gettime(), {1, AV_TIME_BASE}, vctx->time_base); int ret = avcodec_send_frame(vctx, vframe); if (ret < 0) { std::cerr << "Error: Could not send video frame." << std::endl; return EXIT_FAILURE; } while (ret >= 0) { ret = avcodec_receive_packet(vctx, vpacket); if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) break; else if (ret < 0) { std::cerr << "Error: Could not receive video packet." << std::endl; return EXIT_FAILURE; } av_packet_rescale_ts(vpacket, vctx->time_base, vstream->time_base); vpacket->stream_index = vstream->index; // Write video packet to output context av_interleaved_write_frame(outctx, vpacket); av_packet_unref(vpacket); } // Sleep for 40ms to limit framerate to 25fps std::this_thread::sleep_for(std::chrono::milliseconds(40)); } // Cleanup av_write_trailer(outctx); avcodec_free_context(&vctx); av_frame_free(&vframe); av_packet_free(&vpacket); av_frame_free(&frame); avformat_close_input(&outctx); XShmDetach(disp, &shminfo); XDestroyImage(ximg); XCloseDisplay(disp); return EXIT_SUCCESS; } ``` 这个示例代码假设你已经安装了FFmpeg 6.0和X11库，可以通过以下命令来编译它： ``` g++ -o screen_capture screen_capture.cpp -lX11 `pkg-config --cflags --libs libavutil libavcodec libavformat libswscale libswresample` ``` 请注意，这个示例代码只是一个简单的演示，并没有处理错误或异常情况。在实际应用中，你需要根据你的需要添加错误处理和异常处理代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值