//--------------------------------------------------------------
Image::Ptr ReadImage(File* file, FileFormat::Enum ff, PixelFormat::Enum pf)
{
if (!file || (pf != PixelFormat::DontCare && pf < 0)) {
return 0;
}
Image::Ptr image;
switch (ff)
{
case FileFormat::BMP:
{
image = ReadBMP(file);
break;
}
case FileFormat::PNG:
{
image = ReadPNG(file);
break;
}
case FileFormat::JPEG:
{
image = ReadJPEG(file);
break;
}
case FileFormat::AutoDetect:
{
int initial_pos = file->tell();
// try reading as BMP
image = ReadBMP(file);
if (image) {
break;
}
file->seek(initial_pos);
// try reading as PNG
image = ReadPNG(file);
if (image) {
break;
}
file->seek(initial_pos);
// try reading as JPEG
image = ReadJPEG(file);
break;
}
default:
return 0;
}
if (image && pf != PixelFormat::DontCare && image->getPixelFormat() != pf) {
image = image->convert(pf);
}
return image;
}
static int ReadPicture(const char* const filename, WebPPicture* const pic,
int keep_alpha, Metadata* const metadata) {
int ok = 0;
FILE* in_file = fopen(filename, "rb");
if (in_file == NULL) {
fprintf(stderr, "Error! Cannot open input file '%s'\n", filename);
return ok;
}
if (pic->width == 0 || pic->height == 0) {
// If no size specified, try to decode it as PNG/JPEG (as appropriate).
const InputFileFormat format = GetImageType(in_file);
if (format == PNG_) {
ok = ReadPNG(in_file, pic, keep_alpha, metadata);
} else if (format == JPEG_) {
ok = ReadJPEG(in_file, pic, metadata);
} else if (format == TIFF_) {
ok = ReadTIFF(filename, pic, keep_alpha, metadata);
} else if (format == WEBP_) {
ok = ReadWebP(filename, pic, keep_alpha, metadata);
}
} else {
// If image size is specified, infer it as YUV format.
ok = ReadYUV(in_file, pic);
}
if (!ok) {
fprintf(stderr, "Error! Could not process file %s\n", filename);
}
fclose(in_file);
return ok;
}
int R2Image::
Read(const char *filename)
{
// Initialize everything
if (pixels) { delete [] pixels; pixels = NULL; }
width = height = nchannels = 0;
// Parse input filename extension
char *input_extension;
if (!(input_extension = (char*)strrchr(filename, '.'))) {
fprintf(stderr, "Input file has no extension (e.g., .jpg).\n");
return 0;
}
// Read file of appropriate type
if (!strncmp(input_extension, ".bmp", 4)) return ReadBMP(filename);
else if (!strncmp(input_extension, ".png", 4)) return ReadPNG(filename);
else if (!strncmp(input_extension, ".ppm", 4)) return ReadPPM(filename);
else if (!strncmp(input_extension, ".pgm", 4)) return ReadPGM(filename);
else if (!strncmp(input_extension, ".pfm", 4)) return ReadPFM(filename);
else if (!strncmp(input_extension, ".jpg", 4)) return ReadJPEG(filename);
else if (!strncmp(input_extension, ".jpeg", 5)) return ReadJPEG(filename);
// Should never get here
fprintf(stderr, "Unrecognized image file extension");
return 0;
}
ImageData ReadImage(char* fileName)
{
// Check that fileName ends in either jpg or png, and dispatch if so
if (strcmp("png", fileName + strlen(fileName) - 3) == 0)
return ReadPNG(fileName);
else if (strcmp("jpg", fileName + strlen(fileName) - 3) == 0)
return ReadJPG(fileName);
else {
ImageData meta;
meta.valid = false;
return meta;
}
}
PNG::Bitmap *PNG::ReadPNG(const TCHAR *resource)
//----------------------------------------------
{
const char *pData = nullptr;
HGLOBAL hglob = nullptr;
size_t nSize = 0;
if(LoadResource(resource, TEXT("PNG"), pData, nSize, hglob) == nullptr)
{
return nullptr;
}
FileReader file(pData, nSize);
return ReadPNG(file);
}
LDraw::Bitmap* BitmapLoader::Load(IO::ISequentialByteStream* stream)
{
int n;
for (n = 0; n < 5; n++)
{
int ret = -1;
switch (n)
{
case 0:
{
ret = ReadJPEG(this, stream);
}
break;
case 1:
{
ret = ReadGIF(this, stream);
}
break;
case 2:
{
ret = ReadPNG(this, stream);
}
break;
case 3:
{
ret = ReadBMP(this, stream);
}
break;
case 4:
{
ret = ReadTGA(this, stream);
}
break;
}
if (ret == 0)
break;
stream->Seek(0, System::IO::STREAM_SEEK_SET);
}
return m_bitmap;
}
/* Creates an HBITMAP to an image file. returns an HBITMAP if successfull,
// NULL otherwise */
HBITMAP CreateBitmapFromPNGFile( const char *filename,
int blend )
{
char ext[4], msg[256];
char *period;
BMGError out = BMG_OK;
struct BMGImageStruct img;
HBITMAP hBitmap = NULL;
InitBMGImage( &img );
img.opt_for_bmp = 1;
strcpy( msg, filename );
period = strrchr( msg, '.' );
if ( period != NULL )
{
period++;
strncpy( ext, period, 3 );
ext[0] = toupper( ext[0] );
ext[1] = toupper( ext[1] );
ext[2] = toupper( ext[2] );
ext[3] = 0;
}
else
{
strcat( msg, ".PNG" );
strcpy( ext, "PNG" );
}
if ( strcmp( ext, "PNG" ) == 0 )
{
out = ReadPNG( msg, &img );
if ( out == BMG_OK )
{
hBitmap = CreateBitmapFromData( img, blend );
}
FreeBMGImage( &img );
}
else
{
out = errInvalidFileExtension;
}
SetLastBMGError( out );
return hBitmap;
}
/**
* Read a image file into the DIB. This method will check to see if the
* file is a BMP or JPEG and call the appropriate reader.
*/
bool vtDIB::Read(const char *fname, bool progress_callback(int))
{
FILE *fp = vtFileOpen(fname, "rb");
if (!fp)
return false;
uchar buf[2];
if (fread(buf, 2, 1, fp) != 1)
return false;
fclose(fp);
if (buf[0] == 0x42 && buf[1] == 0x4d)
return ReadBMP(fname, progress_callback);
else if (buf[0] == 0xFF && buf[1] == 0xD8)
return ReadJPEG(fname, progress_callback);
else if (buf[0] == 0x89 && buf[1] == 0x50)
return ReadPNG(fname, progress_callback);
return false;
}
//*************************************************************************************
//
//*************************************************************************************
CTexture * CTextureManager::Create( const CString & filename, bool warn )
{
CTexture * p_texture( NULL );
CFile * const p_file( CFileSystem::Open( filename, "rb" ) );
if ( p_file != NULL )
{
const CString extension( p_file->GetExtension() );
if ( extension == "png" || extension == "PNG" )
{
p_texture = ReadPNG( p_file );
}
else if ( extension == "tga" || extension == "TGA" )
{
p_texture = ReadTGA( p_file );
}
else if ( extension == "jpg" || extension == "JPG" )
{
p_texture = ReadJPG( p_file );
}
else if ( extension == "bmp" || extension == "BMP" )
{
p_texture = ReadBMP( p_file );
}
else
{
TRACE( "Unrecognised image extension %s\n", extension.GetPtr() );
ASSERT( 0, "" );
}
CFileSystem::Close( p_file );
}
if ( p_texture == NULL )
{
if ( warn == true )
{
TRACE( "Failed to load image %s\n", filename.GetPtr() );
ASSERT( 0, "" );
}
}
return p_texture;
}
int main (int argc , char ** argv) {
if (argc==3) {
FILE * fp = fopen (argv[1],"rb");
if (fp) {
unsigned int sizex, sizey;
int img_depth,img_alpha;
unsigned char ** row_pointers;
unsigned char * data = ReadPNG(fp,sizex,sizey,img_depth,img_alpha,&row_pointers);
fclose(fp);
if (data&&(img_alpha&PNG_HAS_ALPHA)) {
ModifyImage (sizex,sizey,img_depth,img_alpha&PNG_HAS_ALPHA,row_pointers);
free(row_pointers);
FILE * wr = fopen(argv[2],"wb");
WritePNG(wr,data,sizex,sizey,img_depth,img_alpha&PNG_HAS_ALPHA);
fclose(wr);
}
}
}
}
PngT *PngLoadFromFile(const char *path) {
RwOpsT *stream;
if ((stream = RwOpsFromFile(path, "r"))) {
PngT *png = NewInstance(PngT);
if (ReadPNG(png, stream)) {
LOG("Loaded '%s' file.", path);
} else {
MemUnref(png);
png = NULL;
}
IoClose(stream);
return png;
}
return NULL;
}
int main (int argc , char ** argv) {
if (argc==3) {
FILE * fp = fopen (argv[1],"rb");
if (fp) {
unsigned int sizex, sizey;
int img_depth,img_alpha;
unsigned char ** row_pointers;
unsigned char * data = ReadPNG(fp,sizex,sizey,img_depth,img_alpha,&row_pointers);
fclose(fp);
if (data) {
unsigned char outimage[HEI][WID][3];
ModifyImage (sizex,sizey,img_depth,img_alpha&PNG_HAS_ALPHA,row_pointers,WID,HEI,outimage);
free(row_pointers);
FILE * wr = fopen(argv[2],"wb");
WritePNG(wr,(unsigned char*)outimage,WID,HEI,8,0);
fclose(wr);
}
}
}
}
int main(int argc, char* argv[])
{
(void)argc;
(void)argv;
const int width = 640;
const int height = 480;
const int depth = 32;
Mesh mesh[NUM_MESHES];
ilInit();
iluInit();
//srand(time(NULL));
perspective(clipMatrix, 60.0f, (float)width/(float)height, 1.0f, 40.0f);
for(int i = 0; i < NUM_MESHES; ++i) {
mesh[i].rotationSpeed = rnd_min_max(0.0f, 0.25f);
mesh[i].position.x = rnd_min_max(-1.0f, 1.0f);
mesh[i].position.y = rnd_min_max(-1.0f, 1.0f);
mesh[i].position.z = rnd_min_max(-2.5f, -30.0f);
mesh[i].position.w = 1.0f;
}
SR_Init(width, height);
SR_SetCaption("Tile-Rasterizer Test");
const Texture* tex = ReadPNG("texture0.png");
if(!tex){
printf("Couldn't find texture0.png, aborting..\n");
return -1;
}
SR_BindTexture0(tex);
for(int i=0; i<NUM_MESHES; ++i)
makeMeshCube(mesh[i].vertexData, mesh[i].tcoordData, 1.0f);
SR_MainLoop(loop, quit, (void*)&mesh[0]);
}
ePicture::ePicture(const char* name, const ePoint2& size) : buffer(size)
{
ReadPNG(name, buffer.Data(), size.x, size.y, 4);
}
static void
LoadPNGImage(char *path, Image * img)
{
XImage *ximg;
unsigned char *PngData = NULL, *ptr;
char *ClipData = NULL, *clip_ptr;
int x, y, clipcellmask = 1;
int depth;
XColor Color;
Colormap cmap;
if (ReadPNG(path, &PngData, &img->width, &img->height))
{
Scr->screen = DefaultScreen(dpy);
cmap = Scr->TwmRoot.cmaps.cwins[0]->colormap->c;
depth = Scr->d_depth;
/* XCreateImage only allows 8, 16, 32 as bitmap width */
if (depth != 8 && depth != 16 && depth != 32)
{
if (depth < 8)
depth = 8;
else if (depth < 16)
depth = 16;
else if (depth < 32)
depth = 32;
}
ximg = XCreateImage(dpy, Scr->d_visual, Scr->d_depth, ZPixmap, 0, NULL, img->width, img->height, depth, 0);
if (!ximg)
return;
ximg->data = malloc(ximg->bytes_per_line * ximg->height);
ClipData = calloc(img->width * img->height, 1);
ptr = PngData;
clip_ptr = ClipData;
for (y = 0; y < img->height; y++)
{
for (x = 0; x < img->width; x++)
{
Color.red = (*ptr << 8);
ptr++;
Color.green = (*ptr << 8);
ptr++;
Color.blue = (*ptr << 8);
ptr++;
Color.flags = DoRed | DoGreen | DoBlue;
XAllocColor(dpy, cmap, &Color);
XPutPixel(ximg, x, y, Color.pixel);
if (*ptr > 0)
*clip_ptr |= clipcellmask;
ptr++;
if (clipcellmask == 128)
{
clip_ptr++;
clipcellmask = 1;
}
else
clipcellmask = clipcellmask << 1;
}
}
img->pixmap = XCreatePixmap(dpy, RootWindow(dpy, Scr->screen), img->width, img->height, Scr->d_depth);
XPutImage(dpy, img->pixmap, Scr->NormalGC, ximg, 0, 0, 0, 0, img->width, img->height);
img->mask = XCreatePixmapFromBitmapData(dpy, RootWindow(dpy, Scr->screen), ClipData, img->width, img->height, 1, 0, 1);
img->type = IMAGE_TYPE_PNG;
XDestroyImage(ximg);
}
}
static void Load() {
image = ReadPNG("data/curiousity_by_fool2.png", 0);
PrintPNG(image);
}
