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 格式。