JPEG数据转YUV数据应用实例

已于 2024-07-18 14:41:12 修改
阅读量1.2w 收藏 13
点赞数 3
分类专栏： 视频编码 文章标签： V4l2 MPEG YUV422 JPEG
于 2018-04-24 11:05:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li_wen01/article/details/53765624
版权

    在很多USB摄像头中，质量好点的可以输出很多种数据格式，也有一些只能设置MJPEG模式输出JPEG格式数据，比如我从师弟那顺过来的这颗，哈哈便宜没好货。JPEG数据如果是作为本地存储是没有什么问题的，它在摄像头中已经经过了一次压缩。但是，如果你是需要做视频流，直接使用JPEG格式数据，那么传输的码流就会很大，不利于传输。所以现在基本上所有的视频都是有经过压缩处理的。常见的压缩是H264格式，而H264是需要数据以YUV420格式输入的。对于在硬件平台有限的一些嵌入式设备中，一些大的数据格式装换的库是无法移植到那些平台上去的。比较小的一些JPEG格式装换的库，比如libjpeg和tinyjpegdecoder库，他们好像都是将JPEG数据转换为RGB格式数据，更加可恶的是tinyjpegdecoder库只能在奔腾的处理器上编译通过，因为他底层全部使用的是奔腾的汇编指令。在这里提供另外的一种比较简单的格式装换。

root@ubuntu:/home/share/v4l2MJPEG2YUV422# ll
total 80
drwxr-xr-x  3 root   root    4096 Dec 20 17:17 ./
drwxrwxrwx 13 root   root    4096 Dec 20 15:57 ../
-rwxr--r--  1 ysj002 ysj002  4012 Nov 17  2015 color.c*
-rwxr--r--  1 ysj002 ysj002  2902 Nov 17  2015 color.h*
-rwxr--r--  1 ysj002 ysj002  5652 Nov 17  2015 huffman.h*
-rw-r--r--  1 root   root    8729 Dec 17 13:23 main.c
-rw-r--r--  1 root   root     309 Dec 16 19:50 Makefile
drwxr-xr-x  2 root   root    4096 Dec 17 13:18 out/
-rwxr--r--  1 ysj002 ysj002 28788 Jul 18 18:22 utils.c*
-rwxr--r--  1 ysj002 ysj002  2435 Dec 15 19:12 utils.h*

    上面是我的整个测试测试程序，color和 utils 是用网上找的，具体出处我也没有找着，只是在网上有不少的这个程序。我们只需要调utils.h 中的jpeg_decode 这一个接口就可以了。

下面的是我的测试程序main.c

/*=============================================================================
#     FileName: main.c
#         Desc: MJPEG encoder to YUV422P
#       Author: Licaibiao
#      Version: 
#   LastChange: 2016-12-16 
#      History:

=============================================================================*/
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <linux/types.h>
#include <linux/videodev2.h>
#include <malloc.h>
#include <math.h>
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include <assert.h>
#include <sys/time.h>
#include "utils.h"

#define WIDTH		640
#define	HIGHT		480
#define FILE_VIDEO  "/dev/video0"
#define JPG "./out/image%d"

typedef struct{
    void *start;
	int length;
}BUFTYPE;
BUFTYPE *usr_buf;

static unsigned int n_buffer = 0;  
struct timeval time;
unsigned char* mjpeg_buff;
unsigned char* yuyv_buff;
unsigned char* yuv_buff;

float get_main_time(struct timeval* start , int update)
{
	float dt;
	struct timeval now;
	gettimeofday(&now, NULL);
	dt = (float)(now.tv_sec  - start->tv_sec);
	dt += (float)(now.tv_usec - start->tv_usec) * 1e-6;
	
	if (update > 0) {
		start->tv_sec = now.tv_sec;
		start->tv_usec = now.tv_usec;
	}
	
	return dt;
}


int init_mmap(int fd)
{
	/*to request frame cache, contain requested counts*/
	struct v4l2_requestbuffers reqbufs;

	memset(&reqbufs, 0, sizeof(reqbufs));
	reqbufs.count = 4; 	 						
	reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;    
	reqbufs.memory = V4L2_MEMORY_MMAP;				

	if(-1 == ioctl(fd,VIDIOC_REQBUFS,&reqbufs))
	{
		perror("Fail to ioctl 'VIDIOC_REQBUFS'");
		exit(EXIT_FAILURE);
	}
	
	n_buffer = reqbufs.count;
	printf("n_buffer = %d\n", n_buffer);

	usr_buf = calloc(reqbufs.count, sizeof(BUFTYPE));
	if(usr_buf == NULL)
	{
		printf("Out of memory\n");
		exit(-1);
	}

	/*map kernel cache to user process*/
	for(n_buffer = 0; n_buffer < reqbufs.count; ++n_buffer)
	{
		//stand for a frame
		struct v4l2_buffer buf;
		memset(&buf, 0, sizeof(buf));
		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		buf.index = n_buffer;
		
		/*check the information of the kernel cache requested*/
		if(-1 == ioctl(fd,VIDIOC_QUERYBUF,&buf))
		{
			perror("Fail to ioctl : VIDIOC_QUERYBUF");
			exit(EXIT_FAILURE);
		}

		usr_buf[n_buffer].length = buf.length;
		usr_buf[n_buffer].start = (char *)mmap(NULL,buf.length,PROT_READ | PROT_WRITE,MAP_PRIVATE, fd,buf.m.offset);

		if(MAP_FAILED == usr_buf[n_buffer].start)
		{
			perror("Fail to mmap");
			exit(EXIT_FAILURE);
		}
	}
}

int open_camera(void)
{
	int fd;
	/*open video device with block */
	fd = open(FILE_VIDEO, O_RDONLY);
	if(fd < 0)
	{	
		fprintf(stderr, "%s open err \n", FILE_VIDEO);
		exit(EXIT_FAILURE);
	};
	return fd;
}

void init_mjpeg_encode(void)
{
	mjpeg_buff = (unsigned char*)malloc(WIDTH * HIGHT * 2);
	if(mjpeg_buff ==  NULL)
	{
		perror("mjpeg_encode malloc err\n");
	};

	yuyv_buff = (unsigned char*)malloc(WIDTH * HIGHT * 2);
	if(yuyv_buff ==  NULL)
	{
		perror("mjpeg_encode malloc err\n");
	};

	yuv_buff = (unsigned char*)malloc(WIDTH * HIGHT * 2);
	if(yuyv_buff ==  NULL)
	{
		perror("mjpeg_encode malloc err\n");
	};

	memset(yuv_buff, 0, WIDTH * HIGHT * 2);
	
}

void release_mjpeg(void)
{
	free(mjpeg_buff);
	free(yuyv_buff);
	free(yuv_buff);
}

int init_camera(int fd)
{
	struct v4l2_capability 	cap;	/* decive fuction, such as video input */
	struct v4l2_format 	tv_fmt; /* frame format */  
	struct v4l2_fmtdesc 	fmtdesc;/* detail control value */
	struct v4l2_control 	ctrl;
	int ret;
	
	/*show all the support format*/
	memset(&fmtdesc, 0, sizeof(fmtdesc));
	fmtdesc.index = 0 ;                 /* the number to check */
	fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

	/* check video decive driver capability */
	if(ret=ioctl(fd, VIDIOC_QUERYCAP, &cap)<0)
	{
		fprintf(stderr, "fail to ioctl VIDEO_QUERYCAP \n");
		exit(EXIT_FAILURE);
	}
	
	/*judge wherher or not to be a video-get device*/
	if(!(cap.capabilities & V4L2_BUF_TYPE_VIDEO_CAPTURE))
	{
		fprintf(stderr, "The Current device is not a video capture device \n");
		exit(EXIT_FAILURE);
	}

	/*judge whether or not to supply the form of video stream*/
	if(!(cap.capabilities & V4L2_CAP_STREAMING))
	{
		printf("The Current device does not support streaming i/o\n");
		exit(EXIT_FAILURE);
	}
	
	printf("\ncamera driver name is : %s\n",cap.driver);
	printf("camera device name is : %s\n",cap.card);
	printf("camera bus information: %s\n",cap.bus_info);

	/*display the format device support*/
	while(ioctl(fd,VIDIOC_ENUM_FMT,&fmtdesc)!=-1)
	{	
		printf("\nsupport device %d.%s\n\n",fmtdesc.index+1,fmtdesc.description);
		fmtdesc.index++;
	}


	/*set the form of camera capture data*/
	tv_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;      /*v4l2_buf_typea,camera must use V4L2_BUF_TYPE_VIDEO_CAPTURE*/
	tv_fmt.fmt.pix.width = 680;
	tv_fmt.fmt.pix.height = 480;
	tv_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;	/*V4L2_PIX_FMT_YYUV*/
	tv_fmt.fmt.pix.field = V4L2_FIELD_NONE;   	/*V4L2_FIELD_NONE V4L2_FIELD_INTERLACED */
	if (ioctl(fd, VIDIOC_S_FMT, &tv_fmt)< 0) 
	{
		fprintf(stderr,"VIDIOC_S_FMT set err\n");
		exit(-1);
		close(fd);
	}

	init_mmap(fd);
}

int start_capture(int fd)
{
	unsigned int i;
	enum v4l2_buf_type type;
	
	/*place the kernel cache to a queue*/
	for(i = 0; i < n_buffer; i++)
	{
		struct v4l2_buffer buf;
		memset(&buf, 0, sizeof(buf));
		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		buf.index = i;

		if(-1 == ioctl(fd, VIDIOC_QBUF, &buf))
		{
			perror("Fail to ioctl 'VIDIOC_QBUF'");
			exit(EXIT_FAILURE);
		}
	}

	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	if(-1 == ioctl(fd, VIDIOC_STREAMON, &type))
	{
		printf("i=%d.\n", i);
		perror("VIDIOC_STREAMON");
		close(fd);
		exit(EXIT_FAILURE);
	}

	return 0;
}

int process_image(void *addr, int length)
{
	FILE *fp;
	static int num = 0;
	char image_name[20];
	
	sprintf(image_name, JPG, num++);
	if((fp = fopen(image_name, "w")) == NULL)
	{
		perror("Fail to fopen");
		exit(EXIT_FAILURE);
	}
	fwrite(addr, WIDTH*HIGHT*2 , 1, fp);
	usleep(500);
	fclose(fp);
	return 0;
}



int read_frame(int fd)
{
	struct v4l2_buffer buf;
	unsigned int i;
	int k = WIDTH;
	int j = HIGHT;

	memset(&buf, 0, sizeof(struct v4l2_buffer));
	buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buf.memory = V4L2_MEMORY_MMAP;

	if(-1 == ioctl(fd, VIDIOC_DQBUF,&buf))
	{
		perror("Fail to ioctl 'VIDIOC_DQBUF'");
		exit(EXIT_FAILURE);
	}

	assert(buf.index < n_buffer);
	memcpy(mjpeg_buff,usr_buf[buf.index].start,usr_buf[buf.index].length);

	jpeg_decode(&yuyv_buff, mjpeg_buff, &k, &j);
	process_image(yuyv_buff, WIDTH * HIGHT*2);

	if(-1 == ioctl(fd, VIDIOC_QBUF,&buf))
	{
		perror("Fail to ioctl 'VIDIOC_QBUF'");
		exit(EXIT_FAILURE);
	}
	return 1;
}


int mainloop(int fd)
{
	int count = 20;
	while(count-- > 0)
	{
		for(;;)
		{
			fd_set fds;
			struct timeval tv;
			int r;

			FD_ZERO(&fds);
			FD_SET(fd,&fds);

			/*Timeout*/
			tv.tv_sec = 0;
			tv.tv_usec = 200000;
			r = select(fd + 1,&fds,NULL,NULL,&tv);
			
			if(-1 == r)
			{
				 if(EINTR == errno)
					continue;
				perror("Fail to select");
				exit(EXIT_FAILURE);
			}
			if(0 == r)
			{
				fprintf(stderr,"select Timeout\n");
				exit(-1);
			}

			if(read_frame(fd))
			{
			    break;
			}
		}
	}
	return 0;
}

void stop_capture(int fd)
{
	enum v4l2_buf_type type;
	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	if(-1 == ioctl(fd,VIDIOC_STREAMOFF,&type))
	{
		perror("Fail to ioctl 'VIDIOC_STREAMOFF'");
		exit(EXIT_FAILURE);
	}
}

void close_camera_device(int fd)
{
	unsigned int i;
	for(i = 0;i < n_buffer; i++)
	{
		if(-1 == munmap(usr_buf[i].start,usr_buf[i].length))
		{
			exit(-1);
		}
	}

	free(usr_buf);

	if(-1 == close(fd))
	{
		perror("Fail to close fd");
		exit(EXIT_FAILURE);
	}
}

void main(void)
{
	int fd;
	float ret = 0;
	fd = open_camera();
	init_mjpeg_encode();
	init_camera(fd);
	start_capture(fd);
	ret = get_main_time(&time , 1);
	mainloop(fd);
	ret = get_main_time(&time , 1);
	printf("encode spend time = %f\n",ret);
	stop_capture(fd);
	release_mjpeg();
	close_camera_device(fd);
}

编译执行：

root@ubuntu:/home/share/v4l2MJPEG2YUV422# make clean
rm -f *.o a.out test core *~ *.avi ./out/*
root@ubuntu:/home/share/v4l2MJPEG2YUV422# make
gcc    -c -o main.o main.c
gcc    -c -o color.o color.c
gcc    -c -o utils.o utils.c
gcc  -o test main.o  color.o utils.o 
root@ubuntu:/home/share/v4l2MJPEG2YUV422# ./test 

camera driver name is : gspca_zc3xx
camera device name is : PC Camera
camera bus information: usb-0000:02:00.0-2.1

support device 1.JPEG

n_buffer = 4
encode spend time = 1.699855
root@ubuntu:/home/share/v4l2MJPEG2YUV422# ls ./out/
image0  image10  image12  image14  image16  image18  image2  image4  image6  image8
image1  image11  image13  image15  image17  image19  image3  image5  image7  image9
root@ubuntu:/home/share/v4l2MJPEG2YUV422# 
root@ubuntu:/home/share/v4l2MJPEG2YUV422#

可以看到已经采集了20张图片，该图片已经由JPEG装换为YUYV格式数据，它属于YUV422格式。使用pYUV 工具查看图片的时候，需要按下面的参数配置：



转换后的图片如下：

上面图片颜色偏绿，这个应该是我摄像头的问题，摄像头刚开始启动的几秒时间颜色都偏绿，后面就恢复正常。

完整的工程代码可以在这里下载：JPEG数据格式转YUV数据格式

li_wen01
关注
专栏目录
jpg转yuv，jpg解码纯c实现，无任何第三方库
10-24
jpg转yuv420/yuv444 ,包括jpg头解析、Huffman解码 、IDCT等。纯C语言实现无任何第三方库。使用方法:代码编译后运行 ./main ./3.jpg ./4.yuv 444 第一个参数是输入jpg路径，第二个参数是输出yuv路径，第三个参数是输出格式。已经在windos和linux和arm上验证通过。已知BUG：通过photo shop转换出来的jpg文件解码会失败，原因是头部信息解析异常，建议通过windos自带的画图工具另存为jpg文件后解码。
jpeg图片转成yuv格式图片
12-19
将利用matlab 将100张 jpeg格式图片转成 YUV格式图片
怎么将JPEG转成YUV
weixin_42610010的博客
12-22 1095
将JPEG转换为YUV的方法如下： 使用图像处理库(如OpenCV)读取JPEG图像并将其转换为RGB图像。 使用RGB转YUV转换公式将RGB图像转换为YUV图像。具体来说，可以使用以下公式： Y = 0.299R + 0.587G + 0.114B U = -0.147R - 0.289G + 0.436B V = 0.615R - 0.515G - 0.100B 将转换后的YUV图...
【音视频 | YUV格式】深入理解 YUV 数据格式，一文弄懂
最新发布
wkd_007的博客
08-20 2797
👉本文介绍了YUV的采样格式、存储格式，以及十几种YUV格式：YUV444类型(`I444、YV24、NV24、NV42、YUV444 Packed`)、YUV422类型(`I422、YV16、NV16、NV61、YUVY、VYUY、UYVY`)、YUV420类型(`I420、YV12、NV12、NV21`)。
RAW、YUV、RGB、JPEG格式简介
yaoming168的专栏
09-23 9881
文章目录1.RAW与YUV2.rawRGB、RGB和YUV数据格式与转换3.YUV、RGB、RAW DATA、JPEG 4种方式区别3.1 YUV、RGB、RAW DATA、JPEG 定义3.2 为何要拍摄RAW？3.3 JPEG格式有什么优点？ 1.RAW与YUV 背景，可感受光强度的传感器可以制造出能拍出黑白照片（是灰度图）的相机。但如果需要彩色图像，这种技术就无能为力了，因为当时的传感器只能感知光的强度，而无法感知颜色，也就是频率或波段。如果想要获得不同波段的光，最直接的做法是加入不同颜色的滤镜，从而
如何将jpg等格式的图片转化为yuv
laoyouji的专栏
08-24 7870
1. 下载ffmpeg，转码图片和视频的利器啊！官方免费下载地址：https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-4.2-win64-static.zip 2. 无需安装，解压缩之后即可使用。这时需要使用windows的cmd运行命令行来进行转码: 先定位到bin文件夹下面： cd C:\ffmpeg-4.2-win64.........
RGB YUV jpeg
weixin_30830327的博客
10-22 325
RGB YUV jpeg [转] 1.什么是RGB？RGB是红绿蓝三原色的意思，R=Red、G=Green、B=Blue。2.什么是YUV/YCbCr/YPbPr？亮度信号经常被称作Y，色度信号是由两个互相独立的信号组成。视颜色系统和格式不同，两种色度信号经常被称作U和V或Pb和Pr或Cb和Cr。这些都是由不同的编码格式所产生的，但是实际上，他们的概念基本相同。在DVD中，色度信号被存储...
opencv把jpg图片转化成yuv数据_opencv把Mat转换成yuv
cumtchw
06-10 3074
1 sprintf(imagepath, "/mnt/md/test/mtcnn/images/%d.jpg", i); 4 printf("imagepath:%s\n", imagepath); 5 cv::Mat cv_img = cv::imread(imagepath, 3); 6 if (cv_img.empty()) 7 { 8 fprin...
【FFmpeg命令】jpg与yuv（批量）互转
哈哈哈
09-03 5281
目录1. 单图像jpg转yuv2. 单图像yuv转jpg3. 批量jpg转yuv3.1 bat文件3.2 python的PIL模块3.3 实现思路3.4 参考代码3.5 小问题4. 批量yuv转jpg FFmpeg是一套可以用来记录、转换数字音频、视频，并能将其转化为流的开源计算机程序，其命令行十分丰富。 关于FFmpeg的安装与配置，上一篇博文已经做过介绍了，此文不再赘述。本文重点讲解如何使用 FFmpeg 命令行实现 jpg 与 yuv 图像格式的相互转换，并支持批量化。 1. 单图像jpg转yuv 倘
快速的将YUV444转成YUV420格式数据
08-28
标题"快速的将YUV444转成YUV420格式数据"涉及到的核心知识点是YUV色彩空间的转换，特别是从YUV444到YUV420的下采样过程。YUV444格式中，每个像素都有独立的Y（亮度）、U（蓝色差）和V（红色差）分量，而YUV420则采用...
基于libjpeg的将yuv转成jpg
01-03
在“基于libjpeg的将yuv转成jpg”这个项目中，我们利用libjpeg库的功能将YUV格式的图像数据转化为JPEG格式，以便进行保存或进一步的处理。 转换过程通常包括以下步骤： 1. 初始化：首先，我们需要初始化libjpeg库...
Jpg图片和Bmp图片转为YUV数据
04-21
可以将BMP文件和JPG文件转换为YUV数据，可以将YUV数据写成文件，也可以直接在内存中进行操作
YUV与JPEG互转工具
12-20
YUV与JPEG互转工具，MATLAB实现，完全可用。
yuvConvert.zip_jpeg 转yuv 工具_milkwlb_yuv420sp_yuvconvert_yuv转换工具
07-15
这是一个简单的yuv转换工具，实现了YUV420P、yuv420SP、yuv422p、yuv422sp、yuv422pack5种类型，一共25种格式的互相转换，不仅可以处理一帧yuv文件，也可以处理多帧yuv文件
ffmpeg库实现jpeg图像转yuv格式数据源码
06-03
源码通过ffmpeg库实现将jpeg图像转换为yuv420，yuv422，yuv444，rgb24等格式数据
yuv格式转jpg格式
12-08
c++视频解析 yuv转jpg
RGB转YUV的函数
10-07
在你的案例中，你已经实现了从RGB到YUV的转换，但缺少了从JPEG到RGB的步骤。JPEG是一种有损压缩格式，通常需要先解码为RGB，然后才能进行YUV转换。JPEG解码涉及DCT（离散余弦变换）、量化、熵编码等多个环节，这超出...
STM32单片机上RGB数据转为JPEG格式办法.pdf
01-01
1. **RGB565转YUV420**：首先，将RGB565格式的图像数据转换为YUV420格式。这是因为JPEG压缩算法基于YUV颜色空间，而不是RGB，所以这个转换是必要的。 2. **预处理**：对YUV420数据进行预处理，包括分块、离散余弦...
ffmpeg库实现bmp转换为jpeg格式图像
06-02
FFmpeg是一个强大的开源多媒体处理框架，它包含了众多用于音频、视频处理的工具和库，如libavcodec（编码器库）、libavformat（容器格式库...同时，这个项目也为我们提供了一个实际应用FFmpeg进行图像格式转换的实例。
使用turbo jpeg，对yuv数据进行编码的例程
05-28
以下是使用TurboJPEG对YUV数据进行编码的C语言实现例程： ```c #include <stdio.h> #include <stdlib.h> #include <turbojpeg.h> int main(void) { // 声明变量 tjhandle tjHandle = NULL; int width = 640; // 图像宽度 int height = 480; // 图像高度 int subsamp = TJSAMP_420; // 采样格式 unsigned char *yuvBuf = NULL; // 读入的YUV数据 unsigned char *jpegBuf = NULL; // 压缩后的JPEG数据 unsigned long jpegSize = 0; // 压缩后的JPEG数据大小 // 读入YUV数据，此处为示例代码，实际应用中需要根据实际情况读入数据 FILE *fp = fopen("input.yuv", "rb"); if (!fp) { fprintf(stderr, "Error: Failed to open input file.\n"); return 1; } yuvBuf = (unsigned char *) malloc(width * height * 3 / 2); fread(yuvBuf, 1, width * height * 3 / 2, fp); fclose(fp); // 初始化TurboJPEG tjHandle = tjInitCompress(); if (!tjHandle) { fprintf(stderr, "Error: Failed to initialize TurboJPEG.\n"); free(yuvBuf); return 1; } // 压缩YUV数据为JPEG格式 if (tjCompressFromYUV(tjHandle, yuvBuf, width, 0, height, subsamp, &jpegBuf, &jpegSize, 50, 0) < 0) { fprintf(stderr, "Error: Failed to compress YUV data.\n"); tjDestroy(tjHandle); free(yuvBuf); return 1; } // 将压缩后的JPEG数据写入文件，此处为示例代码，实际应用中需要根据实际情况写入数据 fp = fopen("output.jpg", "wb"); if (!fp) { fprintf(stderr, "Error: Failed to open output file.\n"); tjFree(jpegBuf); tjDestroy(tjHandle); free(yuvBuf); return 1; } fwrite(jpegBuf, 1, jpegSize, fp); fclose(fp); // 释放内存 tjFree(jpegBuf); tjDestroy(tjHandle); free(yuvBuf); return 0; } ``` 需要注意的是，此例程仅仅是一个简单的示例代码，实际应用中需要根据实际情况进行修改和完善。同时，TurboJPEG支持的采样格式和压缩参数也较为丰富，具体可以参考TurboJPEG的官方文档进行调整。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

li_wen01

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值