数据压缩第六次作业：TGA文件转换为YUV文件

最新推荐文章于 2020-04-19 19:04:04 发布
最新推荐文章于 2020-04-19 19:04:04 发布
阅读量454 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NTY518/article/details/105458371
版权

一、TGA文件格式基本介绍
TGA（Targa）格式是计算机上应用最广泛的图象格式。在兼顾了BMP的图象质量的同时又兼顾了JPEG的体积优势。并且还有自身的特点：通道效果、方向性。在CG领域常作为影视动画的序列输出格式，因为兼具体积小和效果清晰的特点。
TGA的结构比较简单，属于一种图形、图像数据的通用格式，在多媒体领域有很大影响，是计算机生成图像向电视转换的一种首选格式。TGA图像格式最大的特点是可以做出不规则形状的图形、图像文件，一般图形、图像文件都为四方形，若需要有圆形、菱形甚至是缕空的图像文件时，TGA就可以派上用场了。
TGA可以压缩也可以不压缩，文件格式较为简单。
二、实验内容
通过C++编写程序，实现TGA文件到YUV文件的转换
三、主要思路
1.利用photoshop将JPEG形式的图像转无压缩的TGA图像
2.读取TGA文件的文件头，获取文件信息
3.读取TGA的其他数据
4.将TGA中的数据转入存储RGB三种颜色的数组
5.从RGB转成YUV
四、TGA文件主体架构
PART1：文件信息头TGA FILE HEADER：
包含三部分：
（1）图像信息字段长度：1字节，规定了包含在字段6（Image ID字段）中的字节数，最大的字符数是255，它的值为0，则表示在这个文件中没有图像信息字段
（2）颜色表类型：1字节，其值为0表示没有颜色表，为1表示有颜色表
（3）图像类型：1字节，用于存储各种位深度的伪彩色，真彩色，调配色
此部分结构体定义如下：

typedef struct TGAFILEHEADER1{
	BYTE IDLENGTH;//图像信息字段长度,1个字节,值为0，则表示在这个文件中没有图像信息字段。
	BYTE COLORMAPTYPE;//颜色表类型,1个字节,0 表示没有颜色表，1 表示颜色表存在
	BYTE IMAGETYPE;//图像类型,1个字节
}TGAFILEHEADER1;

PART2： 颜色表规约COLOR MAP SPECIFICATION
包含三部分：
（1）颜色表首地址：2字节，第一个颜色表表项的索引，是装载颜色表的首地址。
（2）颜色表长度：2字节，颜色表表项的数量
（3）颜色表表项大小：1字节，每个表项占用的位数，典型的值有15，16，24，或者32位。
此部分结构体定义如下：

typedef struct TGAFILEHEADER2 {
	WORD FIRSTENTRYINDEX; //颜色表首地址,2字节
	WORD COLORMAPLENTH;//颜色表长度,2字节
	BYTE COLORMAPENTRYSIZE;//颜色表表项大小,1字节
	//每个表项占用的位数，典型的值有15，16，24，或者32位
}TGAFILEHEADER2;

PART3：图像规约IMAGE SPECIFICATION
（1）图像X的起始位置：2字节，图像左下角的水平坐标
（2）图像Y的起始位置：2字节，图像左下角的垂直坐标
（3）图像宽度：2字节
（4）图像高度：2字节
（5）像素深度：1字节，表示每个像素占用的位数，通常的值是8，16，24，32位。
（6）图像描述符：1字节
在这里插入图片描述
0-3位，规定了每个像素属性位的数量；4-5位，这些位用于表示像素数据从文件发送到屏幕的顺序，位4表示从左到右，位5表示从上到下，如下图所示。
在这里插入图片描述
此部分结构体定义如下：

typedef struct TGAFILEHEADER3 {
	WORD XORIGION; //2个字节,图像左下角的水平坐标
	WORD YORIGION;//2个字节,图像左下角的垂直坐标
	WORD IMAGEWIDTH;//2个字节,图像宽度
	WORD IMAGEHEIGHT;//2个字节,图像高度
	BYTE BITDEPTH;//1个字节,像素z深度
	BYTE IMAGEDESCRIPTOR;//1个字节,图像描述符
	//0-3位，规定了每个像素属性位的数量。看field 24（属性类型，Attributes Type）以获取更多信息
	//Targa 16， 该值为 0 或 1；Targa 24，该值为 0；Targa 32，该值为 8
	//4-5位，这些位用于表示像素数据从文件发送到屏幕的顺序
	//00:bottom left,01:bottom right,10:top left,11:top right
	//6-7位，必需为0。
}TGAFILEHEADER3;

五、实验具体流程及结果：
1.首先从photoshop中导入三张JPEG的图片，并将其分别转化为像素深度为16bit，24bit，32bit的三张TGA图片。获得的三张TGA图片分别为：
16.tga：1600✖️1600，16bit像素深度：
在这里插入图片描述
24.tga:1600✖️1600，24bit像素深度
在这里插入图片描述
32.tga：1200✖️1200，32bit像素深度
在这里插入图片描述
2.写代码：
代码中重点部分：
part1:结构体定义：

typedef struct TGAFILEHEADER1{
	BYTE IDLENGTH;//图像信息字段长度,1个字节,值为0，则表示在这个文件中没有图像信息字段。
	BYTE COLORMAPTYPE;//颜色表类型,1个字节,0 表示没有颜色表，1 表示颜色表存在
	BYTE IMAGETYPE;//图像类型,1个字节
}TGAFILEHEADER1;

typedef struct TGAFILEHEADER2 {
	WORD FIRSTENTRYINDEX; //颜色表首地址,2字节
	WORD COLORMAPLENTH;//颜色表长度,2字节
	BYTE COLORMAPENTRYSIZE;//颜色表表项大小,1字节
	//每个表项占用的位数，典型的值有15，16，24，或者32位
}TGAFILEHEADER2;

typedef struct TGAFILEHEADER3 {
	WORD XORIGION; //2个字节,图像左下角的水平坐标
	WORD YORIGION;//2个字节,图像左下角的垂直坐标
	WORD IMAGEWIDTH;//2个字节,图像宽度
	WORD IMAGEHEIGHT;//2个字节,图像高度
	BYTE BITDEPTH;//1个字节,像素z深度
	BYTE IMAGEDESCRIPTOR;//1个字节,图像描述符
	//0-3位，规定了每个像素属性位的数量。看field 24（属性类型，Attributes Type）以获取更多信息
	//Targa 16， 该值为 0 或 1；Targa 24，该值为 0；Targa 32，该值为 8
	//4-5位，这些位用于表示像素数据从文件发送到屏幕的顺序
	//00:bottom left,01:bottom right,10:top left,11:top right
	//6-7位，必需为0。
}TGAFILEHEADER3;

PART2:无调色板的情况（COLORTYPE=0）：

if (FILE_HEADER1.COLORMAPTYPE == 0)//no color chart
	{
		if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
		{
			cout << "Failed to read the data into the buffer!" << endl;
		}
		else
		{
			cout << "Successfully read in the data into the buffer." << endl;
		}
		if (imagedescriptor == 1)//means Targa 16&bottom left
		{
			int j = DataSize / 2;
			for (int i = 0; i < DataSize;)
			{
				ALPHA[j] = DATA[i + 1] & 0b10000000;
				RED[j] = (DATA[i+1] & 0b01111100) << 1;
				GREEN[j] = ((DATA[i+1] & 0b00000011) << 6) | ((DATA[i] & 0b11100000) >> 2);
				BLUE[j] = (DATA[i] & 0b00011111) << 3;
				i += 2;
				j--;
			}
		}
		else if (imagedescriptor == 0)//means Targa 24&bottom left
		{
			int j = DataSize / 3;
			for (int i = 0; i < DataSize;)
			{
				RED[j] = DATA[i + 2];
				GREEN[j] = DATA[i + 1];
				BLUE[j] = DATA[i];
				i += 3;
				j--;
			}
		}
		else if (imagedescriptor == 8)//means Targa 32&bottom left
		{
			int j = DataSize / 4;
			for (int i = 0; i < DataSize;)
			{
				ALPHA[j] = DATA[i + 3];
				RED[j] = DATA[i + 2];
				GREEN[j] = DATA[i + 1];
				BLUE[j] = DATA[i];
				i += 4;
				j--;
			}
		}
		else
		{
			cout << "This picture is too special to analyse!" << endl;
		}
	}

PART3:有调色板的情况（COLORTYPE=1）：

else if(FILE_HEADER1.COLORMAPTYPE == 1)//there is a color chart
	{
		int COLORMAPADDRESS = 0;
		int COLORMAPLENGTH = 0;
		int COLORMAPSIZE = 0;
		int bitsperpixel = 0;
		COLORMAPADDRESS = FILE_HEADER2.FIRSTENTRYINDEX;
		COLORMAPLENGTH = FILE_HEADER2.COLORMAPLENTH;
		COLORMAPSIZE = FILE_HEADER2.COLORMAPENTRYSIZE;
		bitsperpixel = FILE_HEADER3.BITDEPTH;
		unsigned char* COLORMAP = NULL;		
		COLORMAP = (unsigned char*)malloc(COLORMAPSIZE);
		fseek(TGA, COLORMAPADDRESS, SEEK_SET);
		if (fread(COLORMAP, sizeof(unsigned char), COLORMAPSIZE, TGA) == 0)
		{
			cout << "Read Color Map error!" << endl;
		}
		else
		{
			cout << "Successfully read Color Map!" << endl;
		}
		if (COLORMAPSIZE = 16)
		{
			unsigned char* COLORMAP_ALPHA = NULL;
			unsigned char* COLORMAP_RED = NULL;
			unsigned char* COLORMAP_GREEN = NULL;
			unsigned char* COLORMAP_BLUE = NULL;
			COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
			int j = COLORMAPSIZE / 2;
			for (int i = 0; i < COLORMAPSIZE;)
			{
				COLORMAP_ALPHA[j] = COLORMAP[i + 1] & 0b10000000;
				COLORMAP_RED[j] = (COLORMAP[i + 1] & 0b01111100) << 1;
				COLORMAP_GREEN[j] = ((COLORMAP[i + 1] & 0b00000011) << 6) | ((COLORMAP[i] & 0b11100000) >> 2);
				COLORMAP_BLUE[j] = (COLORMAP[i] & 0b00011111) << 3;
				i += 2;
				j--;
			}
			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
			{
				cout << "Failed to read the data into the buffer!" << endl;
			}
			else
			{
				cout << "Successfully read in the data into the buffer." << endl;
			}
			int bytesperpixel = 0;
			bytesperpixel = bitsperpixel / 8;
			int k = DataSize / bytesperpixel;
			for (int i = 0; i < DataSize;)
			{
				if (bytesperpixel == 2)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
						{
							ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
							RED[k - i / 2] = COLORMAP_RED[j];
							GREEN[k - i / 2] = COLORMAP_GREEN[j];
							BLUE[k - i / 2] = COLORMAP_BLUE[j];
							i += 2;
							k--;
						}
					}
				}
				if (bytesperpixel == 3)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
						{
							ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
							RED[k - i / 3] = COLORMAP_RED[j];
							GREEN[k - i / 3] = COLORMAP_GREEN[j];
							BLUE[k - i / 3] = COLORMAP_BLUE[j];
							i += 3;
							k--;
						}
					}
				}
				if (bytesperpixel == 4)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
						{
							ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
							RED[k - i / 4] = COLORMAP_RED[j];
							GREEN[k - i / 4] = COLORMAP_GREEN[j];
							BLUE[k - i / 4] = COLORMAP_BLUE[j];
							i += 4;
							k--;
						}
					}
				}
			}
			free(COLORMAP_ALPHA);
			free(COLORMAP_RED);
			free(COLORMAP_GREEN);
			free(COLORMAP_BLUE);		
		}
		else if (COLORMAPSIZE = 24)
		{
			unsigned char* COLORMAP_RED = NULL;
			unsigned char* COLORMAP_GREEN = NULL;
			unsigned char* COLORMAP_BLUE = NULL;
			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 3);
			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 3);
			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 3);
			int j = COLORMAPSIZE / 3;
			for (int i = 0; i < COLORMAPSIZE;)
			{
				COLORMAP_RED[j] = COLORMAP[i + 2];
				COLORMAP_GREEN[j] = COLORMAP[i + 1];
				COLORMAP_BLUE[j] = COLORMAP[i];
				i += 3;
				j--;
			}
			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
			{
				cout << "Failed to read the data into the buffer!" << endl;
			}
			else
			{
				cout << "Successfully read in the data into the buffer." << endl;
			}
			int bytesperpixel = 0;
			bytesperpixel = bitsperpixel / 8;
			int k = DataSize / bytesperpixel;
			for (int i = 0; i < DataSize;)
			{
				if (bytesperpixel == 2)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
						{
							RED[k - i / 2] = COLORMAP_RED[j];
							GREEN[k - i / 2] = COLORMAP_GREEN[j];
							BLUE[k - i / 2] = COLORMAP_BLUE[j];
							i += 2;
							k--;
						}
					}
				}
				if (bytesperpixel == 3)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
						{
							RED[k - i / 3] = COLORMAP_RED[j];
							GREEN[k - i / 3] = COLORMAP_GREEN[j];
							BLUE[k - i / 3] = COLORMAP_BLUE[j];
							i += 3;
							k--;
						}
					}
				}
				if (bytesperpixel == 4)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
						{
							RED[k - i / 4] = COLORMAP_RED[j];
							GREEN[k - i / 4] = COLORMAP_GREEN[j];
							BLUE[k - i / 4] = COLORMAP_BLUE[j];
							i += 4;
							k--;
						}
					}
				}
			}
			free(COLORMAP_RED);
			free(COLORMAP_GREEN);
			free(COLORMAP_BLUE);
		}
		else if (COLORMAPSIZE = 32)
		{
		    unsigned char* COLORMAP_ALPHA = NULL;
		    unsigned char* COLORMAP_RED = NULL;
		    unsigned char* COLORMAP_GREEN = NULL;
		    unsigned char* COLORMAP_BLUE = NULL;
		    COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    int j = COLORMAPSIZE / 4;
		    for (int i = 0; i < COLORMAPSIZE;)
		    {
			    COLORMAP_ALPHA[j] = COLORMAP[i + 3];
			    COLORMAP_RED[j] = COLORMAP[i + 2];
			    COLORMAP_GREEN[j] = COLORMAP[i + 1];
			    COLORMAP_BLUE[j] = COLORMAP[i];
			    i += 3;
			    j--;
		    }
		    if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
		    {
			    cout << "Failed to read the data into the buffer!" << endl;
		    }
		    else
		    {
			    cout << "Successfully read in the data into the buffer." << endl;
		    } 
		    int bytesperpixel = 0;
		    bytesperpixel = bitsperpixel / 8;
		    int k = DataSize / bytesperpixel;
		    for (int i = 0; i < DataSize;)
		    {
			if (bytesperpixel == 2)
			{
				for (int j = 0; j < COLORMAPSIZE; j++)
				{
					if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
					{
						ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
						RED[k - i / 2] = COLORMAP_RED[j];
						GREEN[k - i / 2] = COLORMAP_GREEN[j];
						BLUE[k - i / 2] = COLORMAP_BLUE[j];
						i += 2;
						k--;
					}
				}
			}
			if (bytesperpixel == 3)
			{
				for (int j = 0; j < COLORMAPSIZE; j++)
				{
					if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
					{
						ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
						RED[k - i / 3] = COLORMAP_RED[j];
						GREEN[k - i / 3] = COLORMAP_GREEN[j];
						BLUE[k - i / 3] = COLORMAP_BLUE[j];
						i += 3;
						k--;
					}
				}
			}
			if (bytesperpixel == 4)
			{
				for (int j = 0; j < COLORMAPSIZE; j++)
				{
					if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
					{
						ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
						RED[k - i / 4] = COLORMAP_RED[j];
						GREEN[k - i / 4] = COLORMAP_GREEN[j];
						BLUE[k - i / 4] = COLORMAP_BLUE[j];
						i += 4;
						k--;
					}
				}
			}
		}
		free(COLORMAP_ALPHA);
		free(COLORMAP_RED);
		free(COLORMAP_GREEN);
		free(COLORMAP_BLUE);
        }
		else
		{
			cout << "This colormap is too special.This program cannot analyse this picture!" << endl;
		}

	}
	else
	{
		cout << "this program cannot analyse this picture!" << endl;
	}

PART4:RGB转换为YUV（rgb2yuv.cpp）：

#include<iostream>
#include<windows.h>
#include<math.h>
#include <cstring>
#include <cstdlib>
#include"header.h"
using namespace std;

void RGBtoYUV(int w,int h,int size,unsigned char*RED_BUFFER,unsigned char*GREEN_BUFFER,unsigned char*BLUE_BUFFER)
{
	FILE* YUV = NULL;
	if (fopen_s(&YUV, "C:\\32.yuv", "wb") != 0)
	{
		cout << "Failed to create the yuv file!" << endl;
	}
	else
	{
		cout << "Successfully created the yuv file!" << endl;
	}
	unsigned char* Y_BUFFER = NULL; 
	unsigned char* U_BUFFER = NULL; 
	unsigned char* V_BUFFER = NULL;
	Y_BUFFER = new unsigned char[size / 3];
	U_BUFFER = new unsigned char[size / 12];
    V_BUFFER = new unsigned char[size / 12];
	for (int i = 0; i < size/3; i++)//caculate Y
	{
		Y_BUFFER[i] = RED_BUFFER[i] * 0.2990 +
			GREEN_BUFFER[i] * 0.5870 +
			BLUE_BUFFER[i] * 0.1140;
		//Y=0.2990*Red+0.5870*Green+0.1440*Blue
		if (Y_BUFFER[i] > 235)
		{
			Y_BUFFER[i] = 235;
		}
		if (Y_BUFFER[i] < 16)
		{
			Y_BUFFER[i] = 16;
		}
		//In order to avoid the overload of the luminace, so we need to reserve some space
	}


	int u = 0;
	for (int i = 0; i < size/3;)//caculate u
	{
		U_BUFFER[u] = (RED_BUFFER[i] + RED_BUFFER[i + 1] + RED_BUFFER[i + w] + RED_BUFFER[i + w + 1]) / 4 * (-0.1684) +
			(GREEN_BUFFER[i] + GREEN_BUFFER[i + 1] + GREEN_BUFFER[i + w] + GREEN_BUFFER[i + w + 1]) / 4 * (-0.3316) +
			(BLUE_BUFFER[i] + BLUE_BUFFER[i + 1] + BLUE_BUFFER[i + w] + BLUE_BUFFER[i + w + 1]) / 4 * (0.500) + 128;
		if (U_BUFFER[u] > 235)
		{
			U_BUFFER[u] = 235;
		}
		if (U_BUFFER[u] < 16)
		{
			U_BUFFER[u] = 16;
		}
		if (i % w == (w-2))
		{
			i = i + w + 2;
		}
		else
		{
			i = i + 2;
		}
		u++;
	}
	int v = 0;
	for (int i = 0; i < size/3;)//caculate v
	{
		V_BUFFER[v] = (RED_BUFFER[i] + RED_BUFFER[i + 1] + RED_BUFFER[i + w] + RED_BUFFER[i + w + 1]) / 4 * (0.5) +
			(GREEN_BUFFER[i] + GREEN_BUFFER[i + 1] + GREEN_BUFFER[i + w] + GREEN_BUFFER[i + w + 1]) / 4 * (-0.4187) +
			(BLUE_BUFFER[i] + BLUE_BUFFER[i + 1] + BLUE_BUFFER[i + w] + BLUE_BUFFER[i + w + 1]) / 4 * (-0.0813) + 128;
		if (V_BUFFER[v] > 235)
		{
			V_BUFFER[v] = 235;
		}
		if (V_BUFFER[v] < 16)
		{
			V_BUFFER[v] = 16;
		}
		if (i % w == (w - 2))
		{
			i = i + w +2;
		}
		else
		{
			i = i + 2;
		}
		v++;
	}
	fwrite(Y_BUFFER, sizeof(unsigned char), size/3, YUV);
	fwrite(U_BUFFER, sizeof(unsigned char), size/12, YUV);
	fwrite(V_BUFFER, sizeof(unsigned char), size/12, YUV);

	
}

完整主函数（main.cpp）：

#include<iostream>
#include<windows.h>
#include<math.h>
#include <cstring>
#include <cstdlib>
#include"header.h"
using namespace std;

typedef struct TGAFILEHEADER1{
	BYTE IDLENGTH;//图像信息字段长度,1个字节,值为0，则表示在这个文件中没有图像信息字段。
	BYTE COLORMAPTYPE;//颜色表类型,1个字节,0 表示没有颜色表，1 表示颜色表存在
	BYTE IMAGETYPE;//图像类型,1个字节
}TGAFILEHEADER1;

typedef struct TGAFILEHEADER2 {
	WORD FIRSTENTRYINDEX; //颜色表首地址,2字节
	WORD COLORMAPLENTH;//颜色表长度,2字节
	BYTE COLORMAPENTRYSIZE;//颜色表表项大小,1字节
	//每个表项占用的位数，典型的值有15，16，24，或者32位
}TGAFILEHEADER2;

typedef struct TGAFILEHEADER3 {
	WORD XORIGION; //2个字节,图像左下角的水平坐标
	WORD YORIGION;//2个字节,图像左下角的垂直坐标
	WORD IMAGEWIDTH;//2个字节,图像宽度
	WORD IMAGEHEIGHT;//2个字节,图像高度
	BYTE BITDEPTH;//1个字节,像素z深度
	BYTE IMAGEDESCRIPTOR;//1个字节,图像描述符
	//0-3位，规定了每个像素属性位的数量。看field 24（属性类型，Attributes Type）以获取更多信息
	//Targa 16， 该值为 0 或 1；Targa 24，该值为 0；Targa 32，该值为 8
	//4-5位，这些位用于表示像素数据从文件发送到屏幕的顺序
	//00:bottom left,01:bottom right,10:top left,11:top right
	//6-7位，必需为0。
}TGAFILEHEADER3;

int main()
{
	FILE* TGA = NULL;
	FILE* RGB = NULL;
	TGAFILEHEADER1 FILE_HEADER1;
	TGAFILEHEADER2 FILE_HEADER2;
	TGAFILEHEADER3 FILE_HEADER3;
	if (fopen_s(&TGA, "C:\\32.tga", "rb") != 0)
	{
        cout << "Failed to open the tga file!" << endl;
	}
	else
	{
	cout << "Successfully opened the tga file!" << endl;
	}
	if (fopen_s(&RGB, "C:\\32.rgb", "wb") != 0)
	{
		cout << "Failed to create the rgb file!" << endl;
	}
	else
	{
		cout << "Successfully created the rgb file!" << endl;
	}
	fseek(TGA, 0L, SEEK_END);
	int FileSize;
	FileSize = ftell(TGA);
	fseek(TGA, 0L, SEEK_SET);
	/*cout << sizeof(TGAFILEHEADER) << endl;*/
	if (fread(&FILE_HEADER1, 1, 3, TGA) == 0)
	{
		cout << "Read File Header1 error!" << endl;
	}
	else
	{
		cout << "Successfully read File Header!" << endl;
	}
	if (FILE_HEADER1.IDLENGTH == 0)
	{
		cout << "There's no Image information words in this picture." << endl;
	}
	else
	{
		cout << "This program cannot analyse this picture!" << endl;
	}
	if (FILE_HEADER1.COLORMAPTYPE == 0)
	{
		cout << "There is no PLTE in this picture." << endl;
	}
	else
	{
		cout << "This Image includes a PLTE!" << endl;
	}
	if (FILE_HEADER1.IMAGETYPE == 2)
	{
		cout << "This is a ture color image!" << endl;
	}
	else
	{
		cout << "This is a ture color image!" << endl;
	}
	if (fread(&FILE_HEADER2, 1, 5, TGA) == 0)
	{
		cout << "Read File Header2 error!" << endl;
	}
	else
	{
		cout << "Successfully read File Header!" << endl;
	}
	int colortype = FILE_HEADER2.COLORMAPENTRYSIZE;
	cout << "The fisrt entry of the index is " << FILE_HEADER2.FIRSTENTRYINDEX << "." << endl;
	cout << "The length of the color map is " << FILE_HEADER2.COLORMAPLENTH << "." << endl;
	cout << "The size of the color map entry is " << colortype << "." << endl;
	if (fread(&FILE_HEADER3, 1, 10, TGA) == 0)
	{
		cout << "Read File Header3 error!" << endl;
	}
	else
	{
		cout << "Successfully read File Header!" << endl;
	}
	int bitdepth = FILE_HEADER3.BITDEPTH;
	int imagedescriptor = FILE_HEADER3.IMAGEDESCRIPTOR;
	cout << "The X-origin of the image is " << FILE_HEADER3.XORIGION << "." << endl;
	cout << "The Y-origin of the image is " << FILE_HEADER3.YORIGION << "." << endl;
	cout << "The width of the image is " << FILE_HEADER3.IMAGEWIDTH << "." << endl;
	cout << "The height of the image is " << FILE_HEADER3.IMAGEHEIGHT << "." << endl;
	cout << "The bitdepth of the image is " << bitdepth << "." << endl;
	cout << "The imagedescripter of the image is " << imagedescriptor << "." << endl;

	int FILEHEADERSIZE = sizeof(FILE_HEADER1) + sizeof(FILE_HEADER1) + sizeof(FILE_HEADER1);
	int width = 0;
	int height = 0;
	width = FILE_HEADER3.IMAGEWIDTH;
	height = FILE_HEADER3.IMAGEHEIGHT;
	int DataSize = 0;
	DataSize = width * height * bitdepth / 8;
	cout << "The size of the data is " << DataSize << "bytes." << endl;

	unsigned char* DATA = NULL;
	unsigned char* RED = NULL;
	unsigned char* GREEN = NULL;
	unsigned char* BLUE = NULL;
	unsigned char* ALPHA = NULL;
	DATA = (unsigned char*)malloc(DataSize);
	RED = (unsigned char*)malloc(height * width);
	GREEN = (unsigned char*)malloc(height * width);
	BLUE = (unsigned char*)malloc(height * width);
	ALPHA = (unsigned char*)malloc(height * width);

	if (FILE_HEADER1.COLORMAPTYPE == 0)//no color chart
	{
		if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
		{
			cout << "Failed to read the data into the buffer!" << endl;
		}
		else
		{
			cout << "Successfully read in the data into the buffer." << endl;
		}
		if (imagedescriptor == 1)//means Targa 16&bottom left
		{
			int j = DataSize / 2;
			for (int i = 0; i < DataSize;)
			{
				ALPHA[j] = DATA[i + 1] & 0b10000000;
				RED[j] = (DATA[i+1] & 0b01111100) << 1;
				GREEN[j] = ((DATA[i+1] & 0b00000011) << 6) | ((DATA[i] & 0b11100000) >> 2);
				BLUE[j] = (DATA[i] & 0b00011111) << 3;
				i += 2;
				j--;
			}
		}
		else if (imagedescriptor == 0)//means Targa 24&bottom left
		{
			int j = DataSize / 3;
			for (int i = 0; i < DataSize;)
			{
				RED[j] = DATA[i + 2];
				GREEN[j] = DATA[i + 1];
				BLUE[j] = DATA[i];
				i += 3;
				j--;
			}
		}
		else if (imagedescriptor == 8)//means Targa 32&bottom left
		{
			int j = DataSize / 4;
			for (int i = 0; i < DataSize;)
			{
				ALPHA[j] = DATA[i + 3];
				RED[j] = DATA[i + 2];
				GREEN[j] = DATA[i + 1];
				BLUE[j] = DATA[i];
				i += 4;
				j--;
			}
		}
		else
		{
			cout << "This picture is too special to analyse!" << endl;
		}
	}
	else if(FILE_HEADER1.COLORMAPTYPE == 1)//there is a color chart
	{
		int COLORMAPADDRESS = 0;
		int COLORMAPLENGTH = 0;
		int COLORMAPSIZE = 0;
		int bitsperpixel = 0;
		COLORMAPADDRESS = FILE_HEADER2.FIRSTENTRYINDEX;
		COLORMAPLENGTH = FILE_HEADER2.COLORMAPLENTH;
		COLORMAPSIZE = FILE_HEADER2.COLORMAPENTRYSIZE;
		bitsperpixel = FILE_HEADER3.BITDEPTH;
		unsigned char* COLORMAP = NULL;		
		COLORMAP = (unsigned char*)malloc(COLORMAPSIZE);
		fseek(TGA, COLORMAPADDRESS, SEEK_SET);
		if (fread(COLORMAP, sizeof(unsigned char), COLORMAPSIZE, TGA) == 0)
		{
			cout << "Read Color Map error!" << endl;
		}
		else
		{
			cout << "Successfully read Color Map!" << endl;
		}
		if (COLORMAPSIZE = 16)
		{
			unsigned char* COLORMAP_ALPHA = NULL;
			unsigned char* COLORMAP_RED = NULL;
			unsigned char* COLORMAP_GREEN = NULL;
			unsigned char* COLORMAP_BLUE = NULL;
			COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
			int j = COLORMAPSIZE / 2;
			for (int i = 0; i < COLORMAPSIZE;)
			{
				COLORMAP_ALPHA[j] = COLORMAP[i + 1] & 0b10000000;
				COLORMAP_RED[j] = (COLORMAP[i + 1] & 0b01111100) << 1;
				COLORMAP_GREEN[j] = ((COLORMAP[i + 1] & 0b00000011) << 6) | ((COLORMAP[i] & 0b11100000) >> 2);
				COLORMAP_BLUE[j] = (COLORMAP[i] & 0b00011111) << 3;
				i += 2;
				j--;
			}
			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
			{
				cout << "Failed to read the data into the buffer!" << endl;
			}
			else
			{
				cout << "Successfully read in the data into the buffer." << endl;
			}
			int bytesperpixel = 0;
			bytesperpixel = bitsperpixel / 8;
			int k = DataSize / bytesperpixel;
			for (int i = 0; i < DataSize;)
			{
				if (bytesperpixel == 2)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
						{
							ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
							RED[k - i / 2] = COLORMAP_RED[j];
							GREEN[k - i / 2] = COLORMAP_GREEN[j];
							BLUE[k - i / 2] = COLORMAP_BLUE[j];
							i += 2;
							k--;
						}
					}
				}
				if (bytesperpixel == 3)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
						{
							ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
							RED[k - i / 3] = COLORMAP_RED[j];
							GREEN[k - i / 3] = COLORMAP_GREEN[j];
							BLUE[k - i / 3] = COLORMAP_BLUE[j];
							i += 3;
							k--;
						}
					}
				}
				if (bytesperpixel == 4)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
						{
							ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
							RED[k - i / 4] = COLORMAP_RED[j];
							GREEN[k - i / 4] = COLORMAP_GREEN[j];
							BLUE[k - i / 4] = COLORMAP_BLUE[j];
							i += 4;
							k--;
						}
					}
				}
			}
			free(COLORMAP_ALPHA);
			free(COLORMAP_RED);
			free(COLORMAP_GREEN);
			free(COLORMAP_BLUE);		
		}
		else if (COLORMAPSIZE = 24)
		{
			unsigned char* COLORMAP_RED = NULL;
			unsigned char* COLORMAP_GREEN = NULL;
			unsigned char* COLORMAP_BLUE = NULL;
			COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 3);
			COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 3);
			COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 3);
			int j = COLORMAPSIZE / 3;
			for (int i = 0; i < COLORMAPSIZE;)
			{
				COLORMAP_RED[j] = COLORMAP[i + 2];
				COLORMAP_GREEN[j] = COLORMAP[i + 1];
				COLORMAP_BLUE[j] = COLORMAP[i];
				i += 3;
				j--;
			}
			if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
			{
				cout << "Failed to read the data into the buffer!" << endl;
			}
			else
			{
				cout << "Successfully read in the data into the buffer." << endl;
			}
			int bytesperpixel = 0;
			bytesperpixel = bitsperpixel / 8;
			int k = DataSize / bytesperpixel;
			for (int i = 0; i < DataSize;)
			{
				if (bytesperpixel == 2)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
						{
							RED[k - i / 2] = COLORMAP_RED[j];
							GREEN[k - i / 2] = COLORMAP_GREEN[j];
							BLUE[k - i / 2] = COLORMAP_BLUE[j];
							i += 2;
							k--;
						}
					}
				}
				if (bytesperpixel == 3)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
						{
							RED[k - i / 3] = COLORMAP_RED[j];
							GREEN[k - i / 3] = COLORMAP_GREEN[j];
							BLUE[k - i / 3] = COLORMAP_BLUE[j];
							i += 3;
							k--;
						}
					}
				}
				if (bytesperpixel == 4)
				{
					for (int j = 0; j < COLORMAPSIZE; j++)
					{
						if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
						{
							RED[k - i / 4] = COLORMAP_RED[j];
							GREEN[k - i / 4] = COLORMAP_GREEN[j];
							BLUE[k - i / 4] = COLORMAP_BLUE[j];
							i += 4;
							k--;
						}
					}
				}
			}
			free(COLORMAP_RED);
			free(COLORMAP_GREEN);
			free(COLORMAP_BLUE);
		}
		else if (COLORMAPSIZE = 32)
		{
		    unsigned char* COLORMAP_ALPHA = NULL;
		    unsigned char* COLORMAP_RED = NULL;
		    unsigned char* COLORMAP_GREEN = NULL;
		    unsigned char* COLORMAP_BLUE = NULL;
		    COLORMAP_ALPHA = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    COLORMAP_RED = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    COLORMAP_GREEN = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    COLORMAP_BLUE = (unsigned char*)malloc(COLORMAPSIZE / 2);
		    int j = COLORMAPSIZE / 4;
		    for (int i = 0; i < COLORMAPSIZE;)
		    {
			    COLORMAP_ALPHA[j] = COLORMAP[i + 3];
			    COLORMAP_RED[j] = COLORMAP[i + 2];
			    COLORMAP_GREEN[j] = COLORMAP[i + 1];
			    COLORMAP_BLUE[j] = COLORMAP[i];
			    i += 3;
			    j--;
		    }
		    if (fread(DATA, sizeof(unsigned char), DataSize, TGA) == 0)
		    {
			    cout << "Failed to read the data into the buffer!" << endl;
		    }
		    else
		    {
			    cout << "Successfully read in the data into the buffer." << endl;
		    } 
		    int bytesperpixel = 0;
		    bytesperpixel = bitsperpixel / 8;
		    int k = DataSize / bytesperpixel;
		    for (int i = 0; i < DataSize;)
		    {
			if (bytesperpixel == 2)
			{
				for (int j = 0; j < COLORMAPSIZE; j++)
				{
					if (j == ((DATA[i] & 0b11111111 << 8) + DATA[i + 1]))
					{
						ALPHA[k - i / 2] = COLORMAP_ALPHA[j];
						RED[k - i / 2] = COLORMAP_RED[j];
						GREEN[k - i / 2] = COLORMAP_GREEN[j];
						BLUE[k - i / 2] = COLORMAP_BLUE[j];
						i += 2;
						k--;
					}
				}
			}
			if (bytesperpixel == 3)
			{
				for (int j = 0; j < COLORMAPSIZE; j++)
				{
					if (j == ((DATA[i] & 0b11111111 << 16) + (DATA[i + 1] & 0b11111111 << 8) + DATA[i + 2]))
					{
						ALPHA[k - i / 3] = COLORMAP_ALPHA[j];
						RED[k - i / 3] = COLORMAP_RED[j];
						GREEN[k - i / 3] = COLORMAP_GREEN[j];
						BLUE[k - i / 3] = COLORMAP_BLUE[j];
						i += 3;
						k--;
					}
				}
			}
			if (bytesperpixel == 4)
			{
				for (int j = 0; j < COLORMAPSIZE; j++)
				{
					if (j == ((DATA[i] & 0b11111111 << 24) + (DATA[i + 1] & 0b11111111 << 16) + (DATA[i + 2] & 0b11111111 << 8) + DATA[i + 3]))
					{
						ALPHA[k - i / 4] = COLORMAP_ALPHA[j];
						RED[k - i / 4] = COLORMAP_RED[j];
						GREEN[k - i / 4] = COLORMAP_GREEN[j];
						BLUE[k - i / 4] = COLORMAP_BLUE[j];
						i += 4;
						k--;
					}
				}
			}
		}
		free(COLORMAP_ALPHA);
		free(COLORMAP_RED);
		free(COLORMAP_GREEN);
		free(COLORMAP_BLUE);
        }
		else
		{
			cout << "This colormap is too special.This program cannot analyse this picture!" << endl;
		}

	}
	else
	{
		cout << "this program cannot analyse this picture!" << endl;
	}

	fwrite(BLUE, sizeof(unsigned char),width*height, RGB);
	fwrite(GREEN, sizeof(unsigned char), width* height, RGB);
	fwrite(RED, sizeof(unsigned char), width* height, RGB);
	RGBtoYUV(width, height, width* height * 3, RED, GREEN, BLUE);
	/*free(DATA);
	free(RED);
	free(ALPHA);
	free(GREEN);
	free(BLUE);*/
}

六、实验结果：
（1）像素深度为16:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
（2）像素深度为24:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
（3）像素深度为32：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

大懒牛睡觉觉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TGA格式转YUV
qq_45422269的博客
04-12 146
TGA扩展文件结构由五部分组成：文件头、图像/颜色表数据、开发者自定义区域、扩展区域和文件尾。 由头文件中的二三字节00 02可以看出是未压缩的真彩色图像，00 00 00 00 18说明一个像素是24位，所以与RGB的格式非常相似，借鉴了之前RGB转YUV的方法。 代码如下： #include<stdio.h> #include<stdlib.h> const int w...
TGA转YUV
csy201710413030的博客
04-12 134
TGA转YUV 1.得到TGA文件 通过https://convertio.co/zh/tga-converter/将jpg文件转换为TGA文件
数据压缩（六）——TGA转YUV
weixin_45430791的博客
04-14 161
感觉编程上还是有些困难，可能理解的还不够，这个TGA转YUV文件的代码拖了比较久。 先来分析一下TGA的文件格式 TGA文件头 TGA FILE HEADER 图像/颜色表数据 IMAGE/COLOR MAP DATA 开发者区域 DEVELOPER AREA 拓展区域 EXTENSION AREA TGA文件注脚 TGA FLIE FOOTER 代码主要关注于1和2两部分数据 文件头可以...
TGA文件转YUV文件（C++实现）
weixin_43416015的博客
04-06 222
算法 1、读取TGA文件文件头，查看颜色表、图像属性。 2、根据颜色表和文件属性，开辟存储空间，动态分配内存 3、根据颜色表和文件属性，判断颜色表是否存在，找到图像数据首地址，颜色表偏移量等。 4、若有颜色表，读取颜色表数据 5、根据图像数据和颜色表、图像属性，从图像数据中读取RGB分量 6、RGB分量向YUV转换 7、输出 一、文件头读取 unsigned char fileheader[18]...
TGA与YUV文件的转换
Tinsley的博客
04-13 208
一、TGA文件介绍 1.简介 TGA（Targa）格式是计算机上应用最广泛的图象格式。在兼顾了BMP的图象质量的同时又兼顾了JPEG的体积优势。并且还有自身的特点：通道效果、方向性。在CG领域常作为影视动画的序列输出格式，因为兼具体积小和效果清晰的特点。 TGA的结构比较简单，属于一种图形、图像数据的通用格式，在多媒体领域有很大影响，是计算机生成图像向电视转换的一种首选格式。TGA图像格式最大的特...
yuv测试文件 444 1280 720含有10帧数据
08-04
yuv测试文件 444 1280 720含有10帧数据 yuv测试文件 444 1280 720含有10帧数据
yuv测试文件 420 1080p50 含有10帧数据
08-04
yuv测试文件 420 1080p50 含有10帧数据 yuv测试文件 420 1080p50 含有10帧数据
yuv2bmp:将 YUV 数据转换为 BMP 格式的数据
06-20
本文将深入探讨如何使用C语言将YUV数据转换为BMP格式，这涉及到颜色空间转换、位图文件结构理解以及数据编码等多个知识点。 首先，让我们了解一下YUV和BMP格式。YUV是一种用于视频和数字电视的色彩空间，它将颜色...
YUV.rar_C 读取YUV文件_YUV数据读取_c yuv_output yuv file_读取YUV文件
最新发布
09-24
本项目涉及的是如何使用C语言来读取YUV文件，并将其数据输出到文本文件，这对于理解YUV格式以及处理相关的视频数据非常重要。 首先，我们需要了解YUV的基本概念。YUV是亮度（Y）和色度（U、V）分离的颜色模型，它将...
yuvit:将图像转换为YUV色彩空间的工具
05-13
命令行工具可将流行格式（png，jpeg等）的图像转换为YUV图像或什至序列。 它可以读取库所有图像格式。 建造 您将需要cmake，make，g ++和libfreeimage。 在Debian / Ubuntu上： sudo apt-get install g++ cmake ...
[20200412]第二次实验：TGA文件转yuv文件
weixin_44049312的博客
04-12 113
TGA格式文件参考资料https://dev.gameres.com/Program/Visual/Other/TGAFormat.htm
TGA转换成YUV420
qq_43310997的博客
04-12 690
目录TGA文件分析TGA简介文件格式分析代码实现main.cpprgb2yuv实验结果及分析 TGA文件分析 TGA简介 TGA是由美国Truevision公司为其显示卡开发的一种图像文件格式，已被国际上的图形、图像工业所接受。现已成为数字化图像，以及运用光线跟踪算法所产生的高质量图像的常用格式。TGA文件的扩展名为.tga，该格式支持压缩，使用不失真的压缩算法，可以带通道图，另外还支持行程编码压...
C++实现TGA到YUV文件转换
m0_46293129的博客
04-06 219
本次试验通过C++，实现将TGA文件转换为YUV文件。目前只支持非压缩无颜色表24、32位格式以及非压缩有颜色表RGB格式的转换。 一、基本原理 1. TGA文件结构 具体参见： 2. RGB2YUV彩色空间转换基本原理 具体参见： 二、试验流程 三、代码实现 //main.cpp #include <stdio.h> #include <windows.h> #incl...
数据压缩实验报告2 TGA转YUV
Tangent_Chase的博客
04-10 256
写在前面： 由于大二上学习C++时没有进行充分的练习，这次的实验先是自己想了很久但是无果，最后只能参考同学的代码。看不懂的地方和同学讨论并逐渐理解。感觉自己的情况就是知道大概的思路方法，但是不知道如何用代码实现。在没有参考的前提下没法自己写出完整的代码，还是需要多思考多练习。 代码： pga_struct.h(用来创建pga文件的结构体) #pragma once #include <win...
TGA（MOV）格式转YUV422
zuodenghuakai的博客
02-27 744
一：tga图像格式 https://blog.csdn.net/blues1021/article/details/45438673 tga存储格式：移小端模式存储，包括格式规定以及RGB数据，也就是BGR形式存放（直接读入即可），图片左上角的一行像素可能放在文件内存中的最后一行，或者文件内存中的一行就是左上角一行数据，tga头文件记录了调色板偏移大小和规格，图像像素的偏移大小和规格，常见格式...
数据压缩（七）——TGA2YUV文件转换
CRR的博客
04-05 392
任务：将tga文件转换为yuv文件 文章目录（一）TGA文件解析1.1 TGA文件结构TGA文件原始文件结构(v1.0)TGA文件扩展文件结构(v2.0) （一）TGA文件解析 1.1 TGA文件结构 TGA文件原始文件结构(v1.0)  &emsp；由两个部分组成：文件头、图像/颜色表数据。 TGA文件扩展文件结构(v2.0)   由5个部分组成：文件头、图像/颜色表数据、开发者自定...
实验二：tga格式图片转yuv格式
weixin_46338184的博客
04-12 200
一、 文件格式 Tga常见的格式有非压缩RGB和压缩RGB两种格式，其他格式的我们在这里不做讲述。文件的第三个Byte位作为标记：2为非压缩RGB格式，10为压缩RGB格式。在此次实验中，分析未压缩的tga图片。 未压缩格式： 名称 偏移 长度 说明 图像信息字段长度 0 1 本字段为1字节无符号整型，指出图像信息字段的长度，其取值范围为0~255，当它为0时，表示没有图像的信息字...
TGA转换为YUV的C++实现方法
szzheng的博客
04-04 614
TGA转换为YUV的C++实现方法 TGA（或TARGA）格式，是Truevision公司开发的一种用于描述位图图像的格式，它能够表示从黑白、索引颜色到RGB颜色的位图，支持Α通道，并支持多种压缩方法，兼具了体积小和效果清晰的特点，成为了CG领域影视动画的常用序列输出格式。 本文通过C++，实现了将TGA格式图像转换为YUV格式。暂时只讨论Image Type Code为2（无压缩、无调色板的RG...
彩色空间转换（修订之后）
zhaly615的博客
04-19 174
文件头 #include "pch.h" #include <iostream> #include <cstdio> #include <fstream> #include <windows.h> #include <malloc.h> #include <stdlib.h> using namespace std; TGA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值