AVFrame 转 std::vector

你可以使用以下代码将 AVFrame 转换为 std::vector：

std::vector<uint8_t> avframeToVector(AVFrame* frame) {
    std::vector<uint8_t> data;
    
    int size = avpicture_get_size(frame->format, frame->width, frame->height);
    data.resize(size);
    
    AVPicture picture;
    avpicture_fill(&picture, data.data(), frame->format, frame->width, frame->height);
    
    for (int i = 0; i < frame->height; i++) {
        memcpy(picture.data[0] + i * picture.linesize[0], frame->data[0] + i * frame->linesize[0], frame->width);
    }
    
    return data;
}

这个函数会将 AVFrame 的数据复制到一个 std::vector，然后返回该向量。请确保你已经包含了必要的头文件，并且在调用此函数之前，已经正确分配了 AVFrame 的数据。

相关问题

ffmpeg mp4转h264 visual studio 中文

首先，你需要下载并安装 FFmpeg。然后，在 Visual Studio 中创建一个新的 C++ 项目。

接下来，你需要在项目的属性中配置 FFmpeg 的路径和链接库。在项目属性中选择“VC++目录”并添加 FFmpeg 的头文件路径和库文件路径。然后在“链接器”选项卡中添加链接库，包括 avcodec.lib、avformat.lib、avutil.lib、swscale.lib 和 swresample.lib。

在代码中，你需要使用 FFmpeg 的 API 来打开 MP4 文件，提取视频流，并将其转换为 H264 格式。以下是一个简单的示例代码：

#include <iostream>
#include <string>
#include <fstream>
#include <vector>

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

int main(int argc, char* argv[])
{
    // Initialize FFmpeg
    av_register_all();
    avcodec_register_all();

    // Open input file
    AVFormatContext* inputContext = nullptr;
    if (avformat_open_input(&inputContext, argv[1], nullptr, nullptr) != 0) {
        std::cerr << "Failed to open input file." << std::endl;
        return -1;
    }

    // Find video stream
    int videoStreamIndex = -1;
    AVCodecParameters* videoCodecParameters = nullptr;
    for (unsigned int i = 0; i < inputContext->nb_streams; i++) {
        AVCodecParameters* codecParameters = inputContext->streams[i]->codecpar;
        if (codecParameters->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoCodecParameters = codecParameters;
            videoStreamIndex = i;
            break;
        }
    }
    if (videoStreamIndex == -1 || videoCodecParameters == nullptr) {
        std::cerr << "Failed to find video stream." << std::endl;
        return -1;
    }

    // Find video codec
    AVCodec* videoCodec = avcodec_find_decoder(videoCodecParameters->codec_id);
    if (videoCodec == nullptr) {
        std::cerr << "Failed to find video codec." << std::endl;
        return -1;
    }

    // Open video codec
    AVCodecContext* videoCodecContext = avcodec_alloc_context3(videoCodec);
    if (avcodec_parameters_to_context(videoCodecContext, videoCodecParameters) != 0) {
        std::cerr << "Failed to copy codec parameters to codec context." << std::endl;
        return -1;
    }
    if (avcodec_open2(videoCodecContext, videoCodec, nullptr) != 0) {
        std::cerr << "Failed to open video codec." << std::endl;
        return -1;
    }

    // Create output file
    std::ofstream outputFile("output.h264", std::ios::binary);
    if (!outputFile) {
        std::cerr << "Failed to create output file." << std::endl;
        return -1;
    }

    // Allocate frame and packet
    AVFrame* frame = av_frame_alloc();
    AVPacket* packet = av_packet_alloc();

    // Initialize scaler
    SwsContext* scalerContext = sws_getContext(
        videoCodecContext->width, videoCodecContext->height, videoCodecContext->pix_fmt,
        videoCodecContext->width, videoCodecContext->height, AV_PIX_FMT_YUV420P,
        SWS_BILINEAR, nullptr, nullptr, nullptr);
    if (scalerContext == nullptr) {
        std::cerr << "Failed to initialize scaler." << std::endl;
        return -1;
    }

    // Read frames and convert
    while (av_read_frame(inputContext, packet) == 0) {
        if (packet->stream_index == videoStreamIndex) {
            // Decode packet
            if (avcodec_send_packet(videoCodecContext, packet) != 0) {
                std::cerr << "Failed to send packet to decoder." << std::endl;
                return -1;
            }
            while (avcodec_receive_frame(videoCodecContext, frame) == 0) {
                // Convert to YUV420P
                AVFrame* scaledFrame = av_frame_alloc();
                scaledFrame->format = AV_PIX_FMT_YUV420P;
                scaledFrame->width = videoCodecContext->width;
                scaledFrame->height = videoCodecContext->height;
                av_frame_get_buffer(scaledFrame, 32);
                sws_scale(scalerContext,
                    frame->data, frame->linesize, 0, videoCodecContext->height,
                    scaledFrame->data, scaledFrame->linesize);

                // Write frame to file
                std::vector<uint8_t> outputBuffer(scaledFrame->width * scaledFrame->height * 3 / 2);
                uint8_t* outputData = outputBuffer.data();
                int outputSize = av_image_copy_to_buffer(
                    outputData, scaledFrame->linesize, scaledFrame->data,
                    scaledFrame->linesize, AV_PIX_FMT_YUV420P, scaledFrame->width, scaledFrame->height, 1);
                outputFile.write(reinterpret_cast<char*>(outputData), outputSize);

                av_frame_unref(scaledFrame);
            }
        }

        av_packet_unref(packet);
    }

    // Cleanup
    av_frame_free(&frame);
    av_packet_free(&packet);
    sws_freeContext(scalerContext);
    avcodec_free_context(&videoCodecContext);
    avformat_close_input(&inputContext);
    outputFile.close();

    return 0;
}

在运行时，你需要将 MP4 文件的路径作为命令行参数传递给程序。程序将将转换后的 H264 数据写入名为“output.h264”的文件中。

注意：这只是一个简单的示例，可能并不适用于所有的 MP4 文件。你需要根据你的需求进行修改和调整。

ffmpeg的I420frame转opencv mat

FFmpeg是一个功能强大的多媒体处理框架，它支持多种格式的转换、流编辑以及编码等操作。而I420是YUV的一种编码格式，常见于视频压缩标准如H.264。OpenCV是一个计算机视觉库，Mat是其核心数据结构，用于存储图像。

要将FFmpeg的I420帧转换为OpenCV的Mat，你可以使用FFmpeg的API通过`libavcodec`库读取I420数据，然后利用OpenCV提供的函数将其转换成Mat。这里是一个简单的示例：

#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>

cv::Mat convertI420ToMat(const uint8_t* i420Data, int width, int height) {
    // 初始化Mat，I420颜色空间有三个分量：Y（亮度），U（蓝色差分），V（红色差分）
    cv::Mat yuv, yuv420sp(height, width, CV_8UC1), bgr;
    
    // 分离YUV通道
    int planes[] = {0, 1, 2};
    int linesize[] = {width, 1, 1};
    avpicture_fill((AVPicture*) &yuv420sp, (uchar*)i420Data, AV_PIX_FMT_YUV420P, width, height);
    for (int plane = 0; plane < 3; ++plane) {
        cv::Mat channel(height, width, CV_8UC1, yuv420sp.data[planes[plane]]);
        if (plane == 0) {
            yuv = channel; // Y Plane is the only one we'll keep in our Mat
        } else {
            cv::split(yuv420sp, bgr);
            channel.copyTo(bgr[plane - 1]);
        }
    }

    // 将YUV转换为BGR
    cvtColor(yuv, bgr, COLOR_YUV2BGR_I420);

    return bgr;
}

// 使用示例
av_register_all();
AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_H264); // 假设视频是H.264编码
std::vector<uint8_t> i420Data = ...; // 获取到的I420数据
AVFrame frame;
...
if (avcodec_decode_video2(codec, &frame, &got_frame, video_buffer)) {
    cv::Mat result = convertI420ToMat(frame.data[0], frame.width, frame.height);
    // 现在result就是OpenCV的Mat，可以进一步处理了
}

注意，这个例子假设你已经解码了一个包含I420帧的视频，并且获取到了帧的数据。实际应用中，你需要根据具体的输入数据来调整。