JPEG转RGB

jpeg解码—libjpeg

在ubuntu要安装libjpeg8-dev

sudo apt install libjpeg8-dev

一、解码流程

int read_JPEG_file(const char *jpegData, char *rgbdata, int size)
{
    struct jpeg_error_mgr jerr;
    struct jpeg_decompress_struct cinfo;
    cinfo.err = jpeg_std_error(&jerr);
    // 1.创建解码对象并初始化
    jpeg_create_decompress(&cinfo);
    // 2.装备解码的数据
    // jpeg_stdio_src(&cinfo,infile);
    jpeg_mem_src(&cinfo, (unsigned char *)jpegData, size);
    // 3.获取jpeg图片文件的参数
    (void)jpeg_read_header(&cinfo, TRUE);
    // Step 4:set parameters for decompression
    // 5.开始解码
    (void)jpeg_start_decompress(&cinfo);
    // 6.申请存储一行数据的内存空间
    int row_stride = cinfo.output_width * cinfo.output_components;
    unsigned char *buffer = malloc(row_stride);
    int i = 0;
    while (cinfo.output_scanline < cinfo.output_height)
    {
        (void)jpeg_read_scanlines(&cinfo, &buffer, 1);
        memcpy(rgbdata + i * 640 * 3, buffer, row_stride);
        i++;
    }
    // 7.解码完成
    (void)jpeg_finish_decompress(&cinfo);
    // 8.释放解码对象
    jpeg_destroy_decompress(&cinfo);
    return 1;
}

二、代码实现：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <linux/videodev2.h> //命令码
#include <sys/mman.h>
#include <jpeglib.h>
#include <linux/fb.h>

int read_JPEG_file(const char *jpegData, char *rgbdata, int size)
{
    struct jpeg_error_mgr jerr;
    struct jpeg_decompress_struct cinfo;
    cinfo.err = jpeg_std_error(&jerr);
    // 1.创建解码对象并初始化
    jpeg_create_decompress(&cinfo);
    // 2.装备解码的数据
    // jpeg_stdio_src(&cinfo,infile);
    jpeg_mem_src(&cinfo, (unsigned char *)jpegData, size);
    // 3.获取jpeg图片文件的参数
    (void)jpeg_read_header(&cinfo, TRUE);
    // Step 4:set parameters for decompression
    // 5.开始解码
    (void)jpeg_start_decompress(&cinfo);
    // 6.申请存储一行数据的内存空间
    int row_stride = cinfo.output_width * cinfo.output_components;
    unsigned char *buffer = malloc(row_stride);
    int i = 0;
    while (cinfo.output_scanline < cinfo.output_height)
    {
        (void)jpeg_read_scanlines(&cinfo, &buffer, 1);
        memcpy(rgbdata + i * 640 * 3, buffer, row_stride);
        i++;
    }
    // 7.解码完成
    (void)jpeg_finish_decompress(&cinfo);
    // 8.释放解码对象
    jpeg_destroy_decompress(&cinfo);
    return 1;
}
int lcdfd = 0;
unsigned int *lcdptr = NULL;
int lcd_w,lcd_h;
void lcd_show_rgb(unsigned char *rgbdata, int w, int h)
{
    unsigned int *ptr = lcdptr;

    for (int i = 0; i < h; i++)
    {
        for (int j = 0; j < w; j++)
        {
            memcpy(ptr+j,rgbdata+j*3,3);
        }
        ptr +=lcd_w;
        rgbdata +=w*3;
    }
}
int main(int argc, const char *argv[])
{

    lcdfd = open("/dev/fb0", O_RDWR);

    //获取lcd信息
    struct fb_var_screeninfo info;
    int lret = ioctl(lcdfd,FBIOGET_VSCREENINFO,&info);
    //虚拟机
    lcd_w = info.xres_virtual;
    lcd_h = info.yres_virtual;
    //开发板
    // lcd_w = info.xres;
    // lcd.h = info.yres;

    lcdptr = (unsigned int *)mmap(NULL, lcd_w * lcd_h * 4, PROT_READ | PROT_WRITE, MAP_SHARED, lcdfd, 0);

    // 1.打开设备
    int fd = open("/dev/video0", O_RDWR);
    if (fd < 0)
    {
        perror("open  video0 faild");
        return -1;
    }
    // 2.获取摄像头支持的格式ioctl
    struct v4l2_fmtdesc v4fmt;
    v4fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    // v4fmt.index = 0;

    int i = 0;
    while (1)
    {
        v4fmt.index = i++;
        int ret = ioctl(fd, VIDIOC_ENUM_FMT, &v4fmt);
        if (ret < 0)
        {
            perror("itctl get fmt faild");
            break;
        }
        printf("index = %d\n", v4fmt.index);
        printf("flags = %d\n", v4fmt.flags);
        printf("description = %s\n", v4fmt.description);
        unsigned char *p = (unsigned char *)&v4fmt.pixelformat;
        printf("pixelformat = %c%c%c%c\n", p[0], p[1], p[2], p[3]);
        printf("reserved[0] = %d\n", v4fmt.reserved[0]);
        printf("------------------------------------------\n");
    }

    // 3.设置采集格式
    struct v4l2_format vfmt;
    vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; //摄像头采集
    vfmt.fmt.pix.width = 640;                //设置宽
    vfmt.fmt.pix.height = 480;               //设置高
    // vfmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; //设置视频采集格式
    vfmt.fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
    int ret = ioctl(fd, VIDIOC_S_FMT, &vfmt);
    if (ret < 0)
    {
        perror("VIDIOC_S_FMT faild");
    }
    //查看是否设置成功

    memset(&vfmt, 0, sizeof(vfmt));
    vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ret = ioctl(fd, VIDIOC_G_FMT, &vfmt); //获取视频采集格式
    if (ret < 0)
    {
        perror("VIDIOC_G_FMT faild");
    }
    printf("vfmt.fmt.pix.width = %d\n", vfmt.fmt.pix.width);
    printf("vfmt.fmt.pix.height  = %d\n", vfmt.fmt.pix.height);
    unsigned char *p = (unsigned char *)&v4fmt.pixelformat;
    printf("pixelformat = %c%c%c%c\n", p[0], p[1], p[2], p[3]);

    // 4.申请内核空间
    struct v4l2_requestbuffers reqbuffer;
    reqbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    reqbuffer.count = 4;                 //申请4个缓冲区
    reqbuffer.memory = V4L2_MEMORY_MMAP; //映射方式
    ret = ioctl(fd, VIDIOC_REQBUFS, &reqbuffer);
    if (ret < 0)
    {
        perror("VIDIOC_REQBUFS faild");
    }
    // 5.映射
    unsigned char *mptr[4]; //保存映射后用户空间首地址
    unsigned int size[4];

    struct v4l2_buffer mapbuffer;
    //初始化type,index
    mapbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    for (int i = 0; i < 4; i++)
    {
        mapbuffer.index = i;
        ret = ioctl(fd, VIDIOC_QUERYBUF, &mapbuffer); //从内核空间查询一空间做映射
        if (ret < 0)
        {
            perror("VIDIOC_QUERYBUF faild");
        }

        mptr[i] = (unsigned char *)mmap(NULL, mapbuffer.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mapbuffer.m.offset);

        size[i] = mapbuffer.length;
        //使用完毕，放回
        ret = ioctl(fd, VIDIOC_QBUF, &mapbuffer);
        if (ret < 0)
        {
            perror("VIDIOC_QBUF faild");
        }
    }

    // 6.开始采集
    int type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    ret = ioctl(fd, VIDIOC_STREAMON, &type);
    if (ret < 0)
    {
        perror("VIDIOC_STREAMON faild");
    }
    //定义一个空间存储解码后的rgb数据
    unsigned char rgbdata[640*480*3];
    while (1)
    {
        // 7.从队列中提取一帧数据
        struct v4l2_buffer readbuffer;
        readbuffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        ret = ioctl(fd, VIDIOC_DQBUF, &readbuffer);
        if (ret < 0)
        {
            perror("VIDIOC_DQBUF faild");
        }
        //显示在lcd上
        
        //把jpeg数据解码为rgb数据
        read_JPEG_file(mptr[readbuffer.index], rgbdata, readbuffer.length);
        lcd_show_rgb(rgbdata, 640,480);
        //通知内核已经使用完毕
        ret = ioctl(fd, VIDIOC_QBUF, &readbuffer);
        if (ret < 0)
        {
            perror("VIDIOC_QBUF faild");
        }
    }

    // 8.停止采集
    ret = ioctl(fd, VIDIOC_STREAMOFF, &type);
    if (ret < 0)
    {
        perror("VIDIOC_STREAMOFF faild");
    }
    // 9.释放映射
    for (int i = 0; i < 4; i++)
    {
        munmap(mptr[i], size[i]);
    }

    // 10.关闭设备
    close(fd);

    return 0;
}

三、编译：

ubuntu版本

gcc video_show_jpeg.c -o jpeg -ljpeg

开发板版本

装备arm版本的libjpeg库把libjpeg目录拷贝到工程当前目录下

arm-linux-gcc -o video_show_jpeg video_show_jpeg.c -L./libjpeg -I./libjpeg -ljpeg

四、在虚拟lcd终端测试：

ubuntu上

打开虚拟终端：ctrl +fn+alt+f3

执行测试