cv::Mat初始化yuv

要初始化YUV格式的cv::Mat，可以使用以下代码：

int width = 640;
int height = 480;

// Allocate memory for YUV image
int size = width * height;
unsigned char *yuv = new unsigned char[size * 3 / 2];

// Fill Y plane with gray color (128)
memset(yuv, 128, size);

// Fill U and V planes with blue and red color (for example)
for (int i = size; i < size * 3 / 4; i++) {
    yuv[i] = 255;  // U plane
}
for (int i = size * 5 / 4; i < size * 3 / 2; i++) {
    yuv[i] = 0;    // V plane
}

// Create cv::Mat object from YUV data
cv::Mat yuvMat(height * 3 / 2, width, CV_8UC1, yuv);

// Release memory
delete[] yuv;

在这个例子中，我们创建一个640x480的YUV图像，其中Y分量填充为灰色，U分量填充为蓝色，V分量填充为红色。最后，我们使用cv::Mat对象来表示这个YUV图像。

相关问题

cv::Mat装载yuv420数据初始化

可以使用 OpenCV 中的 cv::Mat 类来装载 YUV420 数据。YUV420 格式是一种常用的视频格式，其中包含了亮度（Y）和色度（U、V）三个分量，其中 Y 分量占用总数据量的一半，U 和 V 分量各占用数据量的四分之一。

下面是一个示例代码：

// 假设已经读取了 YUV420 数据到 yuv_data 指针中，且图像大小为 width x height
// 初始化 Mat 对象，分别装载亮度、色度 U、色度 V 分量
cv::Mat y_mat(height, width, CV_8UC1, yuv_data);
cv::Mat u_mat(height / 2, width / 2, CV_8UC1, yuv_data + width * height);
cv::Mat v_mat(height / 2, width / 2, CV_8UC1, yuv_data + width * height * 5 / 4);

// 将色度 U、色度 V 分量上采样并合并为彩色图像
cv::Mat uv_mat;
cv::resize(u_mat, uv_mat, cv::Size(width, height / 2), 0, 0, cv::INTER_LINEAR);
cv::resize(v_mat, uv_mat, cv::Size(width, height), 0, 0, cv::INTER_LINEAR);
cv::Mat bgr_mat;
cv::cvtColor(cv::Mat(height, width, CV_8UC3), bgr_mat, cv::COLOR_YUV2BGR_I420);

这里首先使用 `cv::Mat` 对象分别装载 Y、U、V 分量，然后将 U、V 分量上采样到与 Y 分量相同的大小，再将 U、V 分量合并为一张彩色图像。最后使用 `cv::cvtColor` 函数将 YUV420 转换为 BGR 格式的彩色图像。

c++ ffmpeg4.1 cv::mat 转 AV_PIX_FMT_YUV420P 代码

以下是一个简单的示例代码，可以将 OpenCV 的 `cv::Mat` 对象转换为 FFmpeg 的 `AVFrame`，并将其编码为 YUV 420P 格式。

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

int main() {
    // 初始化 FFmpeg
    av_register_all();

    // 创建格式上下文
    AVFormatContext* format_ctx = avformat_alloc_context();
    if (!format_ctx) {
        std::cerr << "Failed to allocate format context" << std::endl;
        return -1;
    }

    // 设置输出格式
    AVOutputFormat* output_fmt = av_guess_format("mp4", nullptr, nullptr);
    if (!output_fmt) {
        std::cerr << "Failed to guess output format" << std::endl;
        return -1;
    }
    format_ctx->oformat = output_fmt;

    // 打开输出文件
    AVIOContext* io_ctx = nullptr;
    if (avio_open(&io_ctx, "output.mp4", AVIO_FLAG_WRITE) < 0) {
        std::cerr << "Failed to open output file" << std::endl;
        return -1;
    }
    format_ctx->pb = io_ctx;

    // 创建视频流
    AVStream* video_stream = avformat_new_stream(format_ctx, nullptr);
    if (!video_stream) {
        std::cerr << "Failed to create video stream" << std::endl;
        return -1;
    }

    // 设置编码器参数
    AVCodecParameters* codec_params = video_stream->codecpar;
    codec_params->codec_type = AVMEDIA_TYPE_VIDEO;
    codec_params->codec_id = output_fmt->video_codec;
    codec_params->width = 640;
    codec_params->height = 480;
    codec_params->format = AV_PIX_FMT_YUV420P;

    // 查找编码器
    AVCodec* codec = avcodec_find_encoder(output_fmt->video_codec);
    if (!codec) {
        std::cerr << "Failed to find encoder" << std::endl;
        return -1;
    }

    // 创建编码器上下文
    AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        std::cerr << "Failed to allocate codec context" << std::endl;
        return -1;
    }
    codec_ctx->codec_type = AVMEDIA_TYPE_VIDEO;
    codec_ctx->width = codec_params->width;
    codec_ctx->height = codec_params->height;
    codec_ctx->pix_fmt = codec_params->format;
    codec_ctx->time_base = {1, 25};

    // 打开编码器
    if (avcodec_open2(codec_ctx, codec, nullptr) < 0) {
        std::cerr << "Failed to open codec" << std::endl;
        return -1;
    }

    // 创建帧
    AVFrame* frame = av_frame_alloc();
    if (!frame) {
        std::cerr << "Failed to allocate frame" << std::endl;
        return -1;
    }
    frame->format = codec_ctx->pix_fmt;
    frame->width = codec_ctx->width;
    frame->height = codec_ctx->height;

    // 分配帧数据空间
    if (av_frame_get_buffer(frame, 0) < 0) {
        std::cerr << "Failed to allocate frame data" << std::endl;
        return -1;
    }

    // 创建格式转换器
    SwsContext* sws_ctx = sws_getContext(codec_ctx->width, codec_ctx->height, AV_PIX_FMT_BGR24,
                                         codec_ctx->width, codec_ctx->height, codec_ctx->pix_fmt,
                                         SWS_BICUBIC, nullptr, nullptr, nullptr);
    if (!sws_ctx) {
        std::cerr << "Failed to create format converter" << std::endl;
        return -1;
    }

    // 读取输入帧
    cv::Mat input_frame = cv::imread("input.jpg");
    if (input_frame.empty()) {
        std::cerr << "Failed to read input frame" << std::endl;
        return -1;
    }

    // 转换输入帧
    uint8_t* input_data[AV_NUM_DATA_POINTERS] = {0};
    input_data[0] = input_frame.data;
    int input_linesize[AV_NUM_DATA_POINTERS] = {0};
    input_linesize[0] = input_frame.step;
    sws_scale(sws_ctx, input_data, input_linesize, 0, codec_ctx->height, frame->data, frame->linesize);

    // 编码帧
    AVPacket pkt;
    av_init_packet(&pkt);
    pkt.data = nullptr;
    pkt.size = 0;
    int got_packet = 0;
    if (avcodec_encode_video2(codec_ctx, &pkt, frame, &got_packet) < 0) {
        std::cerr << "Failed to encode frame" << std::endl;
        return -1;
    }

    // 写入输出文件
    if (got_packet) {
        av_packet_rescale_ts(&pkt, codec_ctx->time_base, video_stream->time_base);
        pkt.stream_index = video_stream->index;
        if (av_interleaved_write_frame(format_ctx, &pkt) < 0) {
            std::cerr << "Failed to write packet" << std::endl;
            return -1;
        }
        av_packet_unref(&pkt);
    }

    // 写入文件尾
    av_write_trailer(format_ctx);

    // 释放资源
    avcodec_free_context(&codec_ctx);
    av_frame_free(&frame);
    avio_closep(&format_ctx->pb);
    avformat_free_context(format_ctx);
    sws_freeContext(sws_ctx);

    return 0;
}

需要注意的是，上述代码中的 `AV_PIX_FMT_BGR24` 表示输入图像的像素格式，如果您的输入图像格式不是 BGR24，需要相应地修改代码。另外，上述代码中的像素格式硬编码为 YUV420P，如果您需要使用其他像素格式，也需要相应地修改代码。