v4l2 采集 yuy2

v4l2（Video for Linux 2）是 Linux 操作系统下用于视频设备的驱动和 API 接口，支持多种视频流格式的采集和处理。其中，YUY2 是一种常用的色彩空间格式，采用 4:2:2 采样结构，每个像素占据 16 位，用于存储原始视频图像数据。

在 v4l2 中采集 YUY2 格式的视频流，首先需要打开视频设备并设置相关参数，比如帧率、分辨率和颜色空间等。通过调用 V4L2 的 ioctl 系统调用，可以获取相应视频设备的属性信息和控制参数。然后，通过一次读取操作，可以获取一帧 YUY2 格式的视频帧数据。

对于获取到的 YUY2 数据，一般需要进行后续的处理和解码，才能得到可供显示或编码的视频图像格式。常见的解码方式包括使用 FFmpeg、GStreamer 等多媒体库，将 YUY2 数据转换为 RGB、YUV 等常用的视频色彩空间格式。在解码过程中，也可以进行一些自定义的图像处理操作，比如图像旋转、裁剪、缩放等，以满足不同应用场景下的需求。

总之，在 Linux 环境下，使用 v4l2 采集 YUY2 格式的视频流，可以为很多视频应用领域（比如视频会议、监控系统、多媒体播放等）提供高效、可定制的视频处理方案。

相关问题

opencv yuy2

OpenCV中的YUY2是一种色彩编码格式，它使用Y表示亮度信息，U和V表示颜色信息。在转换YUY2到RGB24的函数中，通过对YUV值的计算，将YUY2格式的图像转换为RGB24格式的图像。具体的转换过程如下：

1. 首先，根据输入图像的宽度和高度，使用双重循环遍历每个像素点。

2. 通过判断z的值，确定当前像素点的YUV值的索引。当z为0时，取yuyv作为Y的值，否则取yuyv作为Y的值。

3. 获取当前像素点的U和V的值，并减去128进行偏移，得到u和v。

4. 根据以下公式计算R、G、B的值：
r = (y + (359 * v)) >> 8;
g = (y - (88 * u) - (183 * v)) >> 8;
b = (y + (454 * u)) >> 8;

5. 对计算得到的R、G、B值进行范围限制，保证它们在0到255之间。

6. 将计算得到的R、G、B值依次存储到输出图像的对应位置。

7. 根据z的值更新当前像素点的索引，当z为1时，z重置为0，yuyv索引增加4。否则继续保持z为0，yuyv索引增加2。

8. 循环结束后，返回值为0，表示转换成功完成。

这个函数的作用是将YUY2格式的图像转换为RGB24格式的图像，从而方便后续的图像处理和分析。<span class="em">1</span>
#### 引用[.reference_title]
- *1* [YUY2转RGB](https://blog.csdn.net/u013470224/article/details/68065731)[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^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"]
[ .reference_list ]

libjpeg 库解码yuy2

libjpeg 库本身不支持直接解码 YUY2 格式的图像，因为它只支持 RGB 或灰度图像。因此，如果要使用 libjpeg 库解码 YUY2 格式的图像，需要先将 YUY2 转换为 RGB 格式，然后再使用 libjpeg 库进行解码。

以下是一个用于将 YUY2 转换为 RGB 格式的函数：

void yuy2_to_rgb(unsigned char *src, unsigned char *dst, int width, int height)
{
    int y, u, v;
    int r, g, b;
    unsigned char *yuy2, *rgb;
    yuy2 = src;
    rgb = dst;
    for (int i = 0; i < width * height; i += 2) {
        y = yuy2[0];
        u = yuy2[1] - 128;
        v = yuy2[3] - 128;
        r = y + (1.370705 * v);
        g = y - (0.698001 * v) - (0.337633 * u);
        b = y + (1.732446 * u);
        if (r < 0) {
            r = 0;
        }
        if (g < 0) {
            g = 0;
        }
        if (b < 0) {
            b = 0;
        }
        if (r > 255) {
            r = 255;
        }
        if (g > 255) {
            g = 255;
        }
        if (b > 255) {
            b = 255;
        }
        *rgb++ = r;
        *rgb++ = g;
        *rgb++ = b;
        y = yuy2[2];
        r = y + (1.370705 * v);
        g = y - (0.698001 * v) - (0.337633 * u);
        b = y + (1.732446 * u);
        if (r < 0) {
            r = 0;
        }
        if (g < 0) {
            g = 0;
        }
        if (b < 0) {
            b = 0;
        }
        if (r > 255) {
            r = 255;
        }
        if (g > 255) {
            g = 255;
        }
        if (b > 255) {
            b = 255;
        }
        *rgb++ = r;
        *rgb++ = g;
        *rgb++ = b;
        yuy2 += 4;
    }
}

使用以上函数将 YUY2 转换为 RGB 后，就可以使用 libjpeg 库进行解码了。下面是一个使用 libjpeg 库解码 YUY2 格式图像的 C++ 代码示例：

#include <iostream>
#include <fstream>
#include <jpeglib.h>
#include <jerror.h>

void yuy2_to_rgb(unsigned char *src, unsigned char *dst, int width, int height)
{
    // YUY2 to RGB conversion
    // ...
}

bool decode_yuy2(unsigned char *yuy2_data, int yuy2_size, unsigned char **rgb_data, int *width, int *height)
{
    // YUY2 decoding
    // ...

    // Convert YUY2 to RGB
    yuy2_to_rgb(yuy2_data, *rgb_data, *width, *height);

    return true;
}

bool decode_jpeg(unsigned char *jpeg_data, int jpeg_size, unsigned char **rgb_data, int *width, int *height)
{
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;

    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);

    jpeg_mem_src(&cinfo, jpeg_data, jpeg_size);

    (void) jpeg_read_header(&cinfo, TRUE);

    (void) jpeg_start_decompress(&cinfo);

    *width = cinfo.output_width;
    *height = cinfo.output_height;
    int row_stride = cinfo.output_width * cinfo.output_components;

    *rgb_data = new unsigned char[row_stride * cinfo.output_height];

    JSAMPROW buffer[1];
    while (cinfo.output_scanline < cinfo.output_height) {
        buffer[0] = &((*rgb_data)[cinfo.output_scanline * row_stride]);
        (void) jpeg_read_scanlines(&cinfo, buffer, 1);
    }

    (void) jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);

    return true;
}

int main()
{
    // Read YUY2 data from file
    std::ifstream yuy2_file("yuy2_data.bin", std::ios::binary);
    yuy2_file.seekg(0, std::ios::end);
    int yuy2_size = yuy2_file.tellg();
    yuy2_file.seekg(0, std::ios::beg);
    unsigned char *yuy2_data = new unsigned char[yuy2_size];
    yuy2_file.read(reinterpret_cast<char *>(yuy2_data), yuy2_size);
    yuy2_file.close();

    // Decode YUY2 to RGB
    unsigned char *rgb_data = nullptr;
    int width = 0;
    int height = 0;
    if (!decode_yuy2(yuy2_data, yuy2_size, &rgb_data, &width, &height)) {
        std::cerr << "Failed to decode YUY2" << std::endl;
        return 1;
    }

    // Encode RGB to JPEG
    unsigned char *jpeg_data = nullptr;
    unsigned long jpeg_size = 0;
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;

    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);

    jpeg_mem_dest(&cinfo, &jpeg_data, &jpeg_size, 0);

    cinfo.image_width = width;
    cinfo.image_height = height;
    cinfo.input_components = 3;
    cinfo.in_color_space = JCS_RGB;

    jpeg_set_defaults(&cinfo);
    jpeg_start_compress(&cinfo, TRUE);

    JSAMPROW row_pointer[1];
    int row_stride = width * 3;
    while (cinfo.next_scanline < cinfo.image_height) {
        row_pointer[0] = &rgb_data[cinfo.next_scanline * row_stride];
        (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }

    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);

    // Write JPEG data to file
    std::ofstream jpeg_file("output.jpg", std::ios::binary);
    jpeg_file.write(reinterpret_cast<char *>(jpeg_data), jpeg_size);
    jpeg_file.close();

    // Clean up
    delete[] yuy2_data;
    delete[] rgb_data;
    delete[] jpeg_data;

    return 0;
}

在上述代码中，`decode_yuy2` 函数用于将 YUY2 格式的图像解码为 RGB 格式，`decode_jpeg` 函数用于解码 JPEG 格式的图像。在 `main` 函数中，我们首先读取 YUY2 格式的图像数据，然后将其解码为 RGB 格式，接着使用 RGB 格式的图像数据编码为 JPEG 格式，并将其写入文件中。最后，我们释放了分配的内存空间。

需要注意的是，以上代码中的 `yuy2_to_rgb` 函数只是一个简单的将 YUY2 格式转换为 RGB 格式的示例，实际应用中可能需要更复杂的算法来处理不同的 YUV 格式。