编写一个基于C++的函数，将ffmpeg的AVFrame转换为opencv的Mat

可以使用以下代码实现该功能：

#include <opencv2/opencv.hpp>
#include <libavformat/avformat.h>
#include <libavutil/imgutils.h>
#include <libavutil/frame.h>
#include <libswscale/swscale.h>

cv::Mat avframeToMat(AVFrame* frame)
{
if (!frame) {
return cv::Mat();
}

AVFrame tempFrame;
av_frame_ref(&tempFrame, frame);

int width = tempFrame.width;
int height = tempFrame.height;

cv::Mat mat(height, width, CV_8UC3, tempFrame.data[0], tempFrame.linesize[0]);

av_frame_unref(&tempFrame);

return mat.clone();
}

注意：需要安装相应的工具包，如opencv、ffmpeg等。

相关问题

基于ffmpeg SDK 和opencv，使用c++语言编写一个函数，将一张图片编码成H264格式推流到本地的rtsp服务器上

可以通过以下代码实现要求：

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <string.h>
#include <unistd.h>
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libavutil/opt.h>
#include <libavutil/mathematics.h>
#include <libavutil/time.h>
#include <libswscale/swscale.h>
#include <libavformat/avformat.h>
#include <opencv2/opencv.hpp>

using namespace cv;

AVCodecContext *codec_ctx = NULL;
AVCodec *codec = NULL;
AVFrame *frame = NULL;
AVPacket *pkt = NULL;
SwsContext* img_convert_ctx = NULL;
int video_stream_index = -1;
AVFormatContext *fmt_ctx = NULL;

// 初始化ffmpeg和opencv相关的数据结构
void init(const char *url, int width, int height, int fps)
{
    av_register_all();
    avcodec_register_all();
    avformat_network_init();

    // 创建输出格式上下文
    avformat_alloc_output_context2(&fmt_ctx, nullptr, "rtsp", url);
    if (!fmt_ctx)
    {
        printf("Could not create output context.\n");
        exit(1);
    }

    // 添加视频流
    codec = avcodec_find_encoder_by_name("libx264");
    if (!codec)
    {
        printf("Codec not found.\n");
        exit(1);
    }

    video_stream_index = avformat_new_stream(fmt_ctx, codec);
    if (video_stream_index < 0)
    {
        printf("Could not allocate stream.\n");
        exit(1);
    }

    codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx)
    {
        printf("Could not allocate codec context.\n");
        exit(1);
    }

    // 设置视频的宽、高、帧率等参数
    codec_ctx->bit_rate = 400000;
    codec_ctx->width = width;
    codec_ctx->height = height;
    codec_ctx->time_base.num = 1;
    codec_ctx->time_base.den = fps;
    codec_ctx->gop_size = 12;
    codec_ctx->max_b_frames = 1;
    codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;

    // 打开编码器
    avcodec_open2(codec_ctx, codec, NULL);

    // 分配AVFrame
    frame = av_frame_alloc();
    if (!frame)
    {
        printf("Could not allocate video frame.\n");
        exit(1);
    }

    frame->format = codec_ctx->pix_fmt;
    frame->width = codec_ctx->width;
    frame->height = codec_ctx->height;

    // 分配AVPacket
    pkt = av_packet_alloc();
    if (!pkt)
    {
        printf("Could not allocate packet.\n");
        exit(1);
    }

    // 初始化SWSContext
    img_convert_ctx = sws_getContext(width, height, AV_PIX_FMT_BGR24,
                                     width, height, AV_PIX_FMT_YUV420P,
                                     0, nullptr, nullptr, nullptr);
    if (!img_convert_ctx)
    {
        printf("Could not initialize conversion context.\n");
        exit(1);
    }

    // 通过调用avio_open2()函数打开输出文件
    if (!(fmt_ctx->flags & AVFMT_NOFILE))
    {
        int ret = avio_open2(&fmt_ctx->pb, url, AVIO_FLAG_WRITE, nullptr, nullptr);
        if (ret < 0)
        {
            printf("Could not open '%s'.\n", url);
            exit(1);
        }
    }

    // 通过调用avformat_write_header()函数写入文件头
    int ret = avformat_write_header(fmt_ctx, nullptr);
    if (ret < 0)
    {
        printf("Could not write header.\n");
        exit(1);
    }
}

// 推流函数，将一帧图像推送到rtsp服务器
void push_frame(Mat &frame)
{
    // 格式转换：将OpenCV中的BGR格式转换成YUV420P格式
    AVFrame *av_frame = av_frame_alloc();
    uint8_t *data[AV_NUM_DATA_POINTERS] = {0};
    int linesize[AV_NUM_DATA_POINTERS] = {0};
    av_frame->data[0] = frame.data;
    av_frame->linesize[0] = frame.cols * 3;
    av_frame->format = AV_PIX_FMT_BGR24;
    av_frame->width = frame.cols;
    av_frame->height = frame.rows;

    sws_scale(img_convert_ctx, av_frame->data, av_frame->linesize,
              0, frame.rows, frame->data, frame->linesize);

    // 初始化AVFrame
    av_frame = av_frame_alloc();
    if (!av_frame)
    {
        printf("Could not allocate video frame.\n");
        exit(1);
    }

    av_frame->format = codec_ctx->pix_fmt;
    av_frame->width = codec_ctx->width;
    av_frame->height = codec_ctx->height;

    ret = av_frame_get_buffer(av_frame, 32);
    if (ret < 0) 
    {
        printf("Could not allocate the video frame data.\n");
        exit(1);
    }

    // 编码一帧视频
    ret = avcodec_send_frame(codec_ctx, av_frame);
    if (ret < 0)
    {
        printf("Error sending a frame for encoding.\n");
        exit(1);
    }

    while (ret >= 0)
    {
        ret = avcodec_receive_packet(codec_ctx, pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            return;
        else if (ret < 0)
        {
            printf("Error during encoding.\n");
            exit(1);
        }
        
        // 将编码后的帧写入文件
        av_packet_rescale_ts(pkt, codec_ctx->time_base, fmt_ctx->streams[video_stream_index]->time_base);
        pkt->stream_index = video_stream_index;
        ret = av_interleaved_write_frame(fmt_ctx, pkt);
        if (ret < 0)
        {
            printf("Error writing video frame.\n");
            exit(1);
        }
    }
}

int main(int argc, char **argv)
{
    const char *url = "rtsp://127.0.0.1:8554/test.sdp";
    int width = 640;
    int height = 480;
    int fps = 30;

    init(url, width, height, fps);

    Mat image;
    VideoCapture cap(0);
    if (!cap.isOpened()) 
    {
        printf("Could not initialize capturing...\n");
        return -1;
    }

    while (1)
    {
        cap >> image;
        if (image.empty())
            break;

        push_frame(image);
    }

    av_write_trailer(fmt_ctx);

    // 释放资源
    sws_freeContext(img_convert_ctx);
    avcodec_free_context(&codec_ctx);
    av_frame_free(&frame);
    av_packet_free(&pkt);
    avformat_free_context(fmt_ctx);

    return 0;
}

该函数使用了OpenCV库来获取摄像头的视频流，使用ffmpeg库将视频流编码成H264格式，并推流到本地的rtsp服务器上。

c++中使用ffmpeg框架将 YVU420SP 格式的buffer转换为 YUV 数据格式，再将 YUV 数据转换为 RGB 数据格式，并最终将 RGB 数据用opencv写入图像文件

要使用 FFmpeg 框架将 YVU420SP 格式的 buffer 转换为 YUV 数据格式，然后将 YUV 数据转换为 RGB 数据格式，并最终用 OpenCV 将 RGB 数据写入图像文件，您可以按照以下步骤进行操作：

1. 首先，确保已经正确配置和安装了 FFmpeg 库和 OpenCV 库，以及相关的头文件和链接库。

2. 创建一个 FFmpeg 的 `AVFrame` 对象，并分配足够的内存空间，用于存储 YUV 数据。

   AVFrame* frame = av_frame_alloc();
   frame->format = AV_PIX_FMT_YUV420P;
   frame->width = width;
   frame->height = height;
   av_frame_get_buffer(frame, 0);

3. 将 YVU420SP 格式的 buffer 数据复制到 `AVFrame` 对象中。

   // 假设 buffer 是存储 YVU420SP 数据的缓冲区
   uint8_t* srcData[3] = { buffer, nullptr, nullptr };
   int srcLinesize[3] = { width, width / 2, width / 2 };

   // 将 buffer 数据复制到 AVFrame 对象中
   av_image_fill_arrays(frame->data, frame->linesize, srcData, AV_PIX_FMT_YUV420P, width, height, 1);

4. 创建一个 FFmpeg 的 `SwsContext` 对象，用于进行 YUV 到 RGB 的图像转换。

   SwsContext* swsContext = sws_getContext(width, height, AV_PIX_FMT_YUV420P, width, height, AV_PIX_FMT_RGB24, 0, nullptr, nullptr, nullptr);

5. 创建一个 `cv::Mat` 对象，用于存储 RGB 数据。

   cv::Mat rgbImage(height, width, CV_8UC3);

6. 使用 `sws_scale` 函数将 YUV 数据转换为 RGB 数据。

   uint8_t* dstData[1] = { rgbImage.data };
   int dstLinesize[1] = { 3 * width };

   sws_scale(swsContext, frame->data, frame->linesize, 0, height, dstData, dstLinesize);

7. 最后，使用 OpenCV 的 `cv::imwrite` 函数将 RGB 数据写入图像文件。

   cv::imwrite("output.jpg", rgbImage);

记得在程序结束前进行清理工作：

// 释放资源
sws_freeContext(swsContext);
av_frame_free(&frame);

请注意，上述代码中的变量和函数调用需要根据实际情况进行修改，并且需要正确链接 FFmpeg 和 OpenCV 库。