高级应用加载TGA BMP PNG JEPG ——包含JPEG解码

最新推荐文章于 2018-05-20 22:40:48 发布
最新推荐文章于 2018-05-20 22:40:48 发布
阅读量827 收藏 1
点赞数
分类专栏： C/C++ 文章标签： CC++ 图像解码
texture.cpp

#include <StdAfx.h>

#include"texture.h"
///JPGE读写操作库头文件
#include "include/jpeglib.h"
PNG读写操作库文件
#include "include/pnglib.h"
///JPGE读写操作库
#pragma comment(lib, "lib/jpeg.lib")
PNG读写操作库
#pragma comment(lib, "lib/png.lib")

/
//          JPEG TEXTURE LOADER
/


/
bool CREATE_Texture(UINT &texture, LPSTR strFileName)
{
 if(!strFileName) return false;
 int components; 
 //Load TGA Image
 if(strstr(strFileName, ".jpg"))
 {
  tImageJPG *pBitMap = NULL;
  pBitMap = Load_JPEG(strFileName,&components);
  if(pBitMap == NULL) return false;
   GLenum format;
   switch(components)///图象类型
   {
   case 1:
    format = GL_LUMINANCE;
    break;
   case 2:
    format = GL_LUMINANCE_ALPHA;
    break;
   case 3:
    format = GL_RGB;
    break;
   case 4:
    format = GL_RGBA;
    break;
   }

   glGenTextures(1, &texture);
   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
   glBindTexture(GL_TEXTURE_2D, texture);
   gluBuild2DMipmaps(GL_TEXTURE_2D, components, pBitMap->sizeX, pBitMap->sizeY, format, GL_UNSIGNED_BYTE, pBitMap->data);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); 
   
   if (pBitMap!=NULL)         
   {
    if (pBitMap->data!=NULL)     
    {
     free(pBitMap->data);   
    }
    free(pBitMap);
   }
   return true;
 }

  Load PNG Image
 else if(strstr(strFileName, ".png"))
 {
  tPNG * pBitMap = NULL;
  pBitMap = LoadPNG(strFileName,&components);
  if(pBitMap == NULL) return false;
   GLenum format;
   switch(components)///图象类型
   {
   case 1:
    format = GL_LUMINANCE;
    break;
   case 2:
    format = GL_LUMINANCE_ALPHA;
    break;
   case 3:
    format = GL_RGB;
    break;
   case 4:
    format = GL_RGBA;
    break;
   }

   glGenTextures(1, &texture);
   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
   glBindTexture(GL_TEXTURE_2D, texture);
   gluBuild2DMipmaps(GL_TEXTURE_2D, components, pBitMap->sizeX, pBitMap->sizeY, format, GL_UNSIGNED_BYTE, pBitMap->data);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); 
   
   if (pBitMap!=NULL)         
   {
    if (pBitMap->data!=NULL)     
    {
     free(pBitMap->data);   
    }
    free(pBitMap);
   }
   return true;
 }
  Load BMP Image
 else if(strstr(strFileName, ".bmp"))
 {
  AUX_RGBImageRec *pImage = NULL; 
  pImage = LoadBMP(strFileName,&components);
   if(pImage == NULL) return false;
   GLenum format;
   switch(components)///图象类型
   {
   case 1:
    format = GL_LUMINANCE;
    break;
   case 2:
    format = GL_LUMINANCE_ALPHA;
    break;
   case 3:
    format = GL_RGB;
    break;
   case 4:
    format = GL_RGBA;
    break;
   }
     /
 glGenTextures(1, &texture);
 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 glBindTexture(GL_TEXTURE_2D, texture);
 gluBuild2DMipmaps(GL_TEXTURE_2D, components, pImage->sizeX, pImage->sizeY, format, GL_UNSIGNED_BYTE, pImage->data);
 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); 
 
 if (pImage!=NULL)         
 {
  if (pImage->data!=NULL)     
  {
   free(pImage->data);   
  }
  free(pImage);
 }
 return true;
 }
  // Load TGA Image
 else if(strstr(strFileName, ".tga"))
 { 
 tTGA *pImage =NULL;

 pImage=LoadTGA(strFileName,&components);
  
 if(pImage == NULL) return false;
 GLenum format;
 switch(components)///图象类型
 {
 case 1:
  format = GL_LUMINANCE;
  break;
 case 2:
  format = GL_LUMINANCE_ALPHA;
  break;
 case 3:
  format = GL_RGB;
  break;
 case 4:
  format = GL_RGBA;
  break;
 }
     /
 glGenTextures(1, &texture);
 glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
 glBindTexture(GL_TEXTURE_2D, texture);
 gluBuild2DMipmaps(GL_TEXTURE_2D, components, pImage->sizeX, pImage->sizeY, format, GL_UNSIGNED_BYTE, pImage->data);
 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR); 
 
 if (pImage!=NULL)         
 {
  if (pImage->data!=NULL)     
  {
   free(pImage->data);   
  }
  free(pImage);
 }
 return true;
 }
 类型不符合
 else return false;
}

///
tImageJPG *Load_JPEG(const char *strfilename,int *components)
{
 
 FILE *pFile;
 
 if((pFile = fopen(strfilename, "rb")) == NULL) 
 {
  MessageBox(NULL, "Error loading jpg file.", "ERROR", MB_OK);
  return NULL;
 }
    struct jpeg_decompress_struct cInfo;
 my_error_mgr jerr;
 // 错误处理
 cInfo.err = jpeg_std_error(&jerr.pub);
 jerr.pub.error_exit = my_error_exit;
 if (setjmp(jerr.setjmp_buffer))
 {
  jpeg_destroy_decompress(&cInfo);
  fclose(pFile);
  cout<<"无法解压 "<<strfilename<<endl;
  fclose(pFile);
  return NULL;
 }
//
  tImageJPG *pImgData = NULL;

 jpeg_create_decompress(&cInfo);

 jpeg_stdio_src(&cInfo, pFile);
 
 pImgData = (tImageJPG*)malloc(sizeof(tImageJPG));

 (*components) =Decompress_JPEG(&cInfo, pImgData);
/
 jpeg_destroy_decompress(&cInfo);
 
 fclose(pFile);
 
 return pImgData;
}


int Decompress_JPEG(jpeg_decompress_struct* cInfo, tImageJPG *pImgData)
{
 jpeg_read_header(cInfo, TRUE);
 
 jpeg_start_decompress(cInfo);
 
 pImgData->rowSpan = cInfo->image_width * cInfo->num_components;
 int components = cInfo->num_components;
 pImgData->sizeX   = cInfo->image_width;
 pImgData->sizeY   = cInfo->image_height;
 
 pImgData->data = new unsigned char[pImgData->rowSpan * pImgData->sizeY];
 
 unsigned char** rowPtr = new unsigned char*[pImgData->sizeY];
 for (int i = 0; i < pImgData->sizeY; i++)
  rowPtr[i] = &(pImgData->data[i*pImgData->rowSpan]);
 
 int rowsRead = cInfo->output_height-1;
 while (cInfo->output_scanline < cInfo->output_height) 
 {
  rowsRead -= jpeg_read_scanlines(cInfo, &rowPtr[rowsRead], cInfo->output_height - rowsRead);
 }
 delete [] rowPtr;
 
 jpeg_finish_decompress(cInfo);
 return components;
}


void my_error_exit (j_common_ptr cinfo)
{
 my_error_ptr myerr = (my_error_ptr) cinfo->err;
 // 输出错误信息
 char buffer[JMSG_LENGTH_MAX];
 (*cinfo->err->format_message) (cinfo, buffer);
 cout<<"libjpeg: "<<buffer<<endl;
 longjmp(myerr->setjmp_buffer, 1);
}

//
AUX_RGBImageRec *LoadBMP(const char *strFileName,int *components)    // 载入位图图象
{
 AUX_RGBImageRec *pBitmap = NULL;
 FILE *pFile = NULL;
 if((pFile = fopen(strFileName, "rb")) == NULL) 
 {
  MessageBox(NULL, "Can't load BMP image!", "ERROR", MB_OK | MB_ICONINFORMATION);
  return NULL;
 }
 pBitmap = auxDIBImageLoad(strFileName);    
 
 (*components) = 3;

 fclose(pFile);

 return pBitmap;          
}

/
tTGA *LoadTGA(const char *strFileName,int *components)
{
 tTGA * pImageData = NULL; 
 FILE *pFile = NULL; 
 WORD width = 0, height = 0; 
 byte length = 0;    
 byte imageType = 0;     
 byte bits = 0;      
    (*components) = 0;     
 int stride = 0;     
 int i = 0;      
 
 if((pFile = fopen(strFileName, "rb")) == NULL) 
 {
  MessageBox(NULL, "Can't load TGA image!", "ERROR", MB_OK | MB_ICONINFORMATION);
  return NULL;
 }
 
 pImageData = (tTGA*)malloc(sizeof(tTGA));
 
 fread(&length, sizeof(byte), 1, pFile);
 
 fseek(pFile,1,SEEK_CUR); 
 
 fread(&imageType, sizeof(byte), 1, pFile);
 
 fseek(pFile, 9, SEEK_CUR); 
 
 fread(&width,  sizeof(WORD), 1, pFile);
 fread(&height, sizeof(WORD), 1, pFile);
 fread(&bits,   sizeof(byte), 1, pFile);
 
 fseek(pFile, length + 1, SEEK_CUR); 
 
 if(imageType != TGA_RLE)
 {
  if(bits == 24 || bits == 32)
  {
   (*components) = bits / 8;
   stride = (*components) * width;
   pImageData->data = ((unsigned char*)malloc(sizeof(unsigned char)*stride*height));
   
   for(int y = 0; y < height; y++)
   {
    unsigned char *pLine = &(pImageData->data[stride * y]);
    
    fread(pLine, stride, 1, pFile);
    
    for(i = 0; i < stride; i += (*components))
    {
     int temp     = pLine[i];
     pLine[i]     = pLine[i + 2];
     pLine[i + 2] = temp;
    }
   }
  }
  else if(bits == 16)
  {
   unsigned short pixels = 0;
   int r=0, g=0, b=0;
   
   (*components) = 3;
   stride = (*components) * width;
   pImageData->data = ((unsigned char*)malloc(sizeof(unsigned char)*stride*height));
   
   for(int i = 0; i < width*height; i++)
   {
    fread(&pixels, sizeof(unsigned short), 1, pFile);
    
    b = (pixels & 0x1f) << 3;
    g = ((pixels >> 5) & 0x1f) << 3;
    r = ((pixels >> 10) & 0x1f) << 3;
    
    pImageData->data[i * 3 + 0] = r;
    pImageData->data[i * 3 + 1] = g;
    pImageData->data[i * 3 + 2] = b;
   }
  } 
  else
        { 
   fclose(pFile);
   if(pImageData!=NULL)
   {
    free(pImageData);
   }
   return NULL;
  }
 }
 else
 {
  byte rleID = 0;
  int colorsRead = 0;
  (*components) = bits / 8;
  stride = (*components) * width;
  
  pImageData->data = ((unsigned char*)malloc(sizeof(unsigned char)*stride*height));
  byte *pColors = ((byte*)malloc(sizeof(byte)*(*components)));
  
  while(i < width*height)
  {
   fread(&rleID, sizeof(byte), 1, pFile);
   
   if(rleID < 128)
   {
    rleID++;
    
    while(rleID)
    {
     fread(pColors, sizeof(byte) * (*components), 1, pFile);
     
     pImageData->data[colorsRead + 0] = pColors[2];
     pImageData->data[colorsRead + 1] = pColors[1];
     pImageData->data[colorsRead + 2] = pColors[0];
     
     if(bits == 32)
      pImageData->data[colorsRead + 3] = pColors[3];
     
     i++;
     rleID--;
     colorsRead += (*components);
    }
   }
   else
   {
    rleID -= 127;
    
    fread(pColors, sizeof(byte) * (*components), 1, pFile);
    
    while(rleID)
    {
     pImageData->data[colorsRead + 0] = pColors[2];
     pImageData->data[colorsRead + 1] = pColors[1];
     pImageData->data[colorsRead + 2] = pColors[0];
     
     if(bits == 32)
      pImageData->data[colorsRead + 3] = pColors[3];
     
     i++;
     rleID--;
     colorsRead += (*components);
    }
   }
  }
 }

 fclose(pFile);
 
 pImageData->sizeX    = width;
 pImageData->sizeY    = height;
 
 return pImageData;
}
/
tPNG *LoadPNG(const char *strFileName,int *components)
{
 FILE *fp;
 png_structp png_ptr;
 png_infop info_ptr;
 unsigned int sig_read = 0;
 png_uint_32 width, height;
 int bit_depth, color_type;
 // 打开文件 
 if((fp = fopen(strFileName, "rb")) == NULL)
 {
  cout<<"无法打开 "<<strFileName<<endl;
  return NULL;
 }
///
 tPNG *pImgData ;

/
 // 创建并初始化read_struct
 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
  NULL, user_error_fn, user_warning_fn);

 if (png_ptr == NULL)
 {
  fclose(fp);
  return NULL;
 }

 info_ptr = png_create_info_struct(png_ptr);
 if (info_ptr == NULL)
 {
  fclose(fp);
  png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
  return NULL;
 }
 // 错误处理
 if (setjmp(png_jmpbuf(png_ptr)))
 {
  png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
  fclose(fp);
  cout<<"无法读取 "<<strFileName<<endl;
  fclose(fp);
  return NULL;
 }
 // 开始读
 png_init_io(png_ptr, fp);

 png_set_sig_bytes(png_ptr, sig_read);

 png_read_info(png_ptr, info_ptr);
 pImgData = (tPNG*)malloc(sizeof(tPNG));
 // 文件信息
 png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,int_p_NULL, int_p_NULL, int_p_NULL);
 pImgData->sizeX = width;
 pImgData->sizeY = height;
 if(color_type == PNG_COLOR_TYPE_GRAY)
 {
  (*components) = 1;
 }
 else if(color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
 {
  (*components) = 2;
 }
 else if(color_type == PNG_COLOR_TYPE_RGB)
 {
  (*components) = 3;
 }
 else if(color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 {
  (*components) = 4;
 }
 // 转换格式
    if (color_type == PNG_COLOR_TYPE_PALETTE)
 {
        png_set_palette_to_rgb(png_ptr);
  (*components) = 3;
 }
    else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
 {
  png_set_expand_gray_1_2_4_to_8(png_ptr);
 }
    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
 {
  png_set_tRNS_to_alpha(png_ptr);
  (*components) = 4;
 }
 if (bit_depth == 16)
 {
        png_set_strip_16(png_ptr);
 }
 else if (bit_depth < 8)
 {
        png_set_packing(png_ptr);
 }
 // 分配内存,需在使用后自行删除
 png_uint_32 rowbytes = width * (*components);
 pImgData->data = new png_byte[rowbytes * height];
 // 读取数据
 for(png_uint_32 y=0; y < height; y++)
 {
  png_bytep row = pImgData->data +  rowbytes * (height - y - 1);
  png_read_rows(png_ptr, &row, png_bytepp_NULL, 1);
 }
 png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
 fclose(fp);
 return pImgData;
}
void user_error_fn(png_structp png_ptr, png_const_charp error_message)
{
 cout<<"libpng error: "<<error_message<<endl;
 if (png_ptr)
 {
  longjmp(png_ptr->jmpbuf, 1);
 }
}

void user_warning_fn(png_structp png_ptr, png_const_charp warning_message)
{
 cout<<"libpng warning: "<<warning_message<<endl;
}

texture.h

#ifndef TEXTURE_H
#define TEXTURE_H

#include "include/jpeglib.h"
#include <setjmp.h>//循环错误结构
#include "include/pnglib.h"


#define TGA_RGB   2
#define TGA_A   3
#define TGA_RLE  10

/TGA结构///
struct tTGA
{
 GLuint sizeX;
 GLuint sizeY;
 unsigned char *data;
};
/PNG结构/
struct tPNG
{
 png_uint_32 sizeX;
 png_uint_32 sizeY;
 png_byte *data;
};
/

typedef struct my_error_mgr
{
jpeg_error_mgr pub;
jmp_buf setjmp_buffer;
} * my_error_ptr;

///

tImageJPG * Load_JPEG(const char * strfilename,int * components);
int Decompress_JPEG(jpeg_decompress_struct* cInfo, tImageJPG * pImgData);
bool CREATE_Texture(UINT &texture, LPSTR strFileName);
AUX_RGBImageRec *LoadBMP(const char *strFileName,int *components);
tTGA *LoadTGA(const char *strFileName,int *components);
tPNG *LoadPNG(const char *strFileName,int *components);
static void my_error_exit (j_common_ptr cinfo);
static void user_error_fn(png_structp png_ptr, png_const_charp error_message);
static void user_warning_fn(png_structp png_ptr, png_const_charp warning_message);

#endif

去找 PNG。LIB PNG。H JPEG。LIB JPEG。H ZLIB。LIB ZLIB。H    （ZLIB 就是 zip）

labrary
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JPEG,BMP,PNG格式文件读取
03-08
当你的程序找不到pngimage这个单元的时候。。。 这段代码会帮助到你。。。 当你的不使用delphi... 或者你的可以正常使用pngimage。。。 那么。。。。 这里你就可以忽略了。。。 下面就是一个简单的用法。可以...
MATLAB实现jpeg编码和解码
10-18
MATLAB实现jpeg编码和解码，包括编码DCT，哈夫曼编码，熵编码
OpenGL中不用AUX库来加载BMP图片作为纹理［转载］
wenxiongkjsm的专栏
11-12 522
<br />大家在OpenGL中一般是用aux库的auxDIBImageLoad()函数来加载BMP格式的图片来作为纹理，这个确实是比较简单易用，但aux库的性能不佳，经常会出问题，稳定性较差。所以一般最好不要用aux库，可以用glut库，但glut库没有纹理加载函数。而有些程序是直接读取BMP格式来获得图像数据，从而生成纹理的，这种方法虽然很强大，但比较复杂，需要了解BMP的格式，对初学者比较困难。而下面的一段程序是用windows的API函数LoadImage()来实现这个功能，这种实现方法很简单，可以
两种加载BMP纹理图像的方法
u014183377的专栏
11-13 1736
两种加载BMP纹理图像的方法      在NeHe上，通过BMP文件来加载纹理，使用的是glaux.h函数库中的auxDIBImageLoad(Filename)函数来解决的，使用起来比较方便，可是，glaux.h这个函数库作为OpenGL平台发展的一个中间过渡产品，存在这不够稳定及功能不够完整的缺点，所以一般不使用这个函数库，而选择glut.h，以下是分别应用这两种函数库来实现纹理图像加载
如何使用opengl 加载tga文件
Qin_xian_shen的博客
05-20 1151
请参考这个教程：https://blog.csdn.net/xiajun07061225/article/details/7646058另外附带上png转化为tga的在线网址https://cn.office-converter.com/PNG-to-TGA
OpenGL ES纹理贴图
xumingrencai
10-16 340
转载自：http://seya.iteye.com/blog/532525 OpenGL可以把纹理映射到指定的图形的表面上。简单一点的，就是给平面映射纹理，比如一个四边形，一个长方体的6个面，都可以指定位图作为纹理映射到各个面上。 关于将一个位图作为纹理映射到某个或者多个面上，可以学习Jeff Molofee的OpenGL系列教程。 对于指定的多个纹理，要根据自己的需要映射到不同的面上，需要...
OpenGL系统设计-纹理贴图(4)
LotusOne的专栏
10-27 2716
1.1        JPEG纹理    大型的应用程序特别是游戏程序使用的贴图非常多，如Quake III使用的JPEG和TGA文件就有将近2000个，其中JPEG文件超过一半，占用近30MB。如果都使用BMP格式的话，因为没有压缩，占用的空间将大大增加，至少达到180MB。因此，JPEG文件作为贴图也是大型程序的选择。因为JPEG文件是压缩的，使用JPEG文件，必须先进行解码。因为JP
JPEG.rar_jepg_jpeg_jpeg source_jpeg 解码
09-20
jepg格式的图片解码，转换和现实程序源代码，比较完整和独立的接口，可以提炼成模块使用
JPEG.rar_JEPG 和JPEG_jepg2000_jpeg_jpeg jepg_matlab；
07-15
JEPG压缩算法的matlab仿真，亲测可用，还可以和JEPG2000对比
基于matlab的JPEG彩色图像编码解码MATLAB完整源码程序
03-31
%JPEG建议量化矩阵 quantizationMatrix=quantizationFactor.*quantizationTable; I=blkproc(I,[8 8],'round(x./P1)',quantizationMatrix);%%向靠近的整数取圆整 %DC系数的DPCM编码 for i=row-7:-8:1 for j=column-...
OpenGL基本概念入门5——纹理贴图2
因为了解所以无知
04-08 3273
4 为图元指定法向量 OpenGL必须通过图元的法线向量来确定图元的明暗程度。只有场景中的物体有了明暗的不同，场景才有立体感。 确定一个平面的法向量是一件相当简单的事情。在一个平面上，随意寻找两个互不平行的向量，它们的外积(叉积)就是这个平面的法线。 计算两向量的外积可以使用公式： Sx = UyVz - UzVy Sy = UzVx - UxVz Sz = UxVy - UyVx 上述公式中，U、V为两不平行向量，S为U、V的外积(即U×V)。计算完外积之后，
不用AuxDIBImageLoad()向opengl中载入bmp纹理
程序人生
12-03 1595
不用AuxDIBImageLoad()向opengl中载入bmp纹理 这个函数从硬盘中加载24位window DIB 位图。呵呵，解释的多了。为了节约时间，我没有加载整个bmp图的Header部分，而仅仅获取我们需要的部分：宽度，高度，和图片大小。 下面是代码部分 unsigned int LoadTex(string Image) { unsigned int Texture;
U3D贴图格式 GENERATE MIP MAPS
zhutaorun的博客
01-24 6838
UI策划问我，是否要勾选上GENERATE MIP MAPS，勾选上后Loading图清晰多了。对此重新去看，以及整理在这里 工作小知识在UITexture的格式上 是否勾选上GENERATE MIP MAPS。 之前问过其他人，说是影响不大。确实在安卓手机上，图片清晰度没有差别，但是 PC端上的海马模拟器上UITexture 图片就显得有差别了。勾选了后，图片显得模糊。 一张图勾选上Gener
Avatar 三维引擎
luoyexunxue的博客
10-15 2168
这是我的一个业余项目，Avatar 是一款跨平台高性能的3D引擎，底层采用 C++ 开发，目前支持 Windows、Linux、 Android 三个平台。渲染部分基于 OpenGL3.3/ES3.0，引擎具有很高的可移植性，除了 freetype、glew、libcurl、 libjpeg、libpng、lua、mpg123、openal、rapidxml、zlib 这些开源的第三方库以...
auxDIBImageLoad详解
HJUGujbwi223的专栏
06-24 5285
bool AUX_RGBImageRec::loadFile(const char* Filename) {         BITMAPINFO BMInfo;                                                              // need the current OpenGL device contexts in order to
png相比于jepg的优势在哪里
最新发布
06-10
PNG和JPEG是两种不同的图像格式，它们各有优缺点，下面是PNG相比JPEG的优势： 1. 无损压缩：PNG使用无损压缩算法，压缩图像文件大小，但不会丢失图像质量和细节。而JPEG使用有损压缩算法，压缩图像文件大小，但在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值