unsigned char *
load_luminance(char *name, int *width, int *height, int *components)
{
unsigned char *base, *lptr;
ImageRec *image;
int y;
image = ImageOpen(name);
if (!image)
return NULL;
if (image->zsize != 1)
return NULL;
*width = image->xsize;
*height = image->ysize;
*components = image->zsize;
base = (unsigned char *)
malloc(image->xsize * image->ysize * sizeof(unsigned char));
if (!base)
return NULL;
lptr = base;
for (y = 0; y < image->ysize; y++) {
ImageGetRow(image, lptr, y, 0);
lptr += image->xsize;
}
ImageClose(image);
return base;
}
bool SGIImageFileType::read( Image *pImage,
std::istream &is,
const std::string &mimetype)
{
ImageRec img;
if(ImageOpen(img, is) == false)
return false;
if((img.zsize < 1) || (img.zsize > 4))
return false;
pImage->set(zsize2pixelformat[img.zsize - 1], img.xsize, img.ysize);
unsigned char *lptr = pImage->editData();
unsigned int lineStride = img.xsize * img.zsize;
for(int y = 0; y < img.ysize; ++y)
{
for(int z = 0; z < img.zsize; ++z)
{
if(ImageGetRow(img, lptr + z, y, z, img.zsize) == false)
return false;
}
lptr += lineStride;
}
return true;
}
GLubyte *
read_alpha_texture(char *name, int *width, int *height)
{
unsigned char *base, *lptr;
ImageRec *image;
int y;
image = ImageOpen(name);
if (!image) {
return NULL;
}
(*width)=image->xsize;
(*height)=image->ysize;
if (image->zsize != 1) {
ImageClose(image);
return NULL;
}
base = (unsigned char *)malloc(image->xsize*image->ysize*sizeof(unsigned char));
lptr = base;
for(y=0; y<image->ysize; y++) {
ImageGetRow(image,lptr,y,0);
lptr += image->xsize;
}
ImageClose(image);
return (GLubyte *) base;
}
unsigned * read_texture(const char *name, int *width, int *height, int *components)
{
unsigned *base, *lptr;
unsigned char *rbuf, *gbuf, *bbuf, *abuf;
ImageRec *image;
int y;
image = ImageOpen(name);
if(!image)
return NULL;
(*width)=image->xsize;
(*height)=image->ysize;
(*components)=image->zsize;
base = (unsigned *)malloc(image->xsize*image->ysize*sizeof(unsigned));
rbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
gbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
bbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
abuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
if(!base || !rbuf || !gbuf || !bbuf)
return NULL;
lptr = base;
for(y=0; y<image->ysize; y++)
{
if(image->zsize>=4)
{
ImageGetRow(image,rbuf,y,0);
ImageGetRow(image,gbuf,y,1);
ImageGetRow(image,bbuf,y,2);
ImageGetRow(image,abuf,y,3);
rgbatorgba(rbuf,gbuf,bbuf,abuf,(unsigned char *)lptr,image->xsize);
lptr += image->xsize;
}
else if(image->zsize==3)
{
ImageGetRow(image,rbuf,y,0);
ImageGetRow(image,gbuf,y,1);
ImageGetRow(image,bbuf,y,2);
rgbtorgba(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
lptr += image->xsize;
}
else
{
ImageGetRow(image,rbuf,y,0);
bwtorgba(rbuf,(unsigned char *)lptr,image->xsize);
lptr += image->xsize;
}
}
ImageClose(image);
free(rbuf);
free(gbuf);
free(bbuf);
free(abuf);
return (unsigned *) base;
}
IMAGE *ImageLoad(char *fileName)
{
Image *image;
IMAGE *final;
int sx;
image = ImageOpen(fileName);
final = (IMAGE *)malloc(sizeof(IMAGE));
GLubyte *
read_rgb_texture(char *name, int *width, int *height)
{
unsigned char *base, *ptr;
unsigned char *rbuf, *gbuf, *bbuf, *abuf;
ImageRec *image;
int y;
image = ImageOpen(name);
if (!image) {
return NULL;
}
(*width)=image->xsize;
(*height)=image->ysize;
if (image->zsize != 3 && image->zsize != 4) {
ImageClose(image);
return NULL;
}
base = (unsigned char*)malloc(image->xsize*image->ysize*sizeof(unsigned int)*3);
rbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
gbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
bbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
abuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
if(!base || !rbuf || !gbuf || !bbuf || !abuf) {
if (base) free(base);
if (rbuf) free(rbuf);
if (gbuf) free(gbuf);
if (bbuf) free(bbuf);
if (abuf) free(abuf);
return NULL;
}
ptr = base;
for(y=0; y<image->ysize; y++) {
if(image->zsize == 4) {
ImageGetRow(image,rbuf,y,0);
ImageGetRow(image,gbuf,y,1);
ImageGetRow(image,bbuf,y,2);
ImageGetRow(image,abuf,y,3); /* Discard. */
rgbtorgb(rbuf,gbuf,bbuf,ptr,image->xsize);
ptr += (image->xsize * 3);
} else {
ImageGetRow(image,rbuf,y,0);
ImageGetRow(image,gbuf,y,1);
ImageGetRow(image,bbuf,y,2);
rgbtorgb(rbuf,gbuf,bbuf,ptr,image->xsize);
ptr += (image->xsize * 3);
}
}
ImageClose(image);
free(rbuf);
free(gbuf);
free(bbuf);
free(abuf);
return (GLubyte *) base;
}
static BOOL HD_Load_Image(const int iDrive, LPCSTR pszImageFilename)
{
const bool bCreateIfNecessary = false; // NB. Don't allow creation of HDV files
string strFilenameInZip; // TODO: Use this
ImageError_e Error = ImageOpen(pszImageFilename, iDrive, bCreateIfNecessary, strFilenameInZip);
g_HardDisk[iDrive].hd_imageloaded = (Error == eIMAGE_ERROR_NONE);
return g_HardDisk[iDrive].hd_imageloaded;
}
/*
* readInCursorFile - Read the cursor file and set up structures.
*/
static BOOL readInCursorFile( char *fname )
{
FILE *fp;
an_img_file *cursorfile;
an_img *cursor;
fp = fopen( fname, "rb" );
if (!fp) {
WImgEditError( WIE_ERR_FILE_NOT_OPENED, fname );
return( FALSE );
}
cursorfile = ImageOpen( fp );
if (!cursorfile) {
fclose( fp );
WImgEditError( WIE_ERR_BAD_CURSOR_FILE, fname );
return( FALSE );
}
cursor = ImgResourceToImg( fp, cursorfile, 0 );
fclose( fp );
return( DoReadCursor( fname, cursorfile, cursor, NULL, NULL ) );
} /* readInCursorFile */
/*
* readInIconFile - read the icon file and set up structures
*/
static BOOL readInIconFile( char *fname )
{
FILE *fp;
an_img_file *iconfile;
img_node *node;
int num_of_images;
HDC hdc;
int i;
an_img *icon;
char filename[_MAX_FNAME + _MAX_EXT];
fp = fopen( fname, "rb" );
if( fp == NULL ) {
WImgEditError( WIE_ERR_FILE_NOT_OPENED, fname );
return( FALSE );
}
GetFnameFromPath( fname, filename );
#ifdef JAMIE
{
char msg[80];
sprintf( msg, "Jamie: IconHeader size = %d", sizeof( an_img_file ) );
MessageBox( HMainWindow, msg, "FYI", MB_OK );
}
#endif
iconfile = ImageOpen( fp );
if( iconfile == NULL ) {
fclose( fp );
WImgEditError( WIE_ERR_BAD_ICON_FILE, filename );
return( FALSE );
}
num_of_images = iconfile->count;
#if 0
/* See biBitCount test below... */
for( i = 0; i < num_of_images; i++ ) {
if( iconfile->resources[i].color_count != 2 &&
iconfile->resources[i].color_count != 8 &&
iconfile->resources[i].color_count != 16 &&
iconfile->resources[i].color_count != 0 ) {
WImgEditError( WIE_ERR_BAD_ICON_CLR, filename );
ImageClose( iconfile );
fclose( fp );
return( FALSE );
}
}
#endif
node = MemAlloc( sizeof( img_node ) * num_of_images );
hdc = GetDC( NULL );
for( i = 0; i < num_of_images; i++ ) {
icon = ImgResourceToImg( fp, iconfile, i );
if( icon->bm->bmiHeader.biBitCount != 4 &&
icon->bm->bmiHeader.biBitCount != 1 &&
icon->bm->bmiHeader.biBitCount != 8 ) {
WImgEditError( WIE_ERR_BAD_ICON_CLR, filename );
ReleaseDC( NULL, hdc );
ImageFini( icon );
ImageClose( iconfile );
fclose( fp );
MemFree( node );
return( FALSE );
}
node[i].imgtype = ICON_IMG;
node[i].bitcount = icon->bm->bmiHeader.biBitCount;
node[i].width = icon->bm->bmiHeader.biWidth;
node[i].height = icon->bm->bmiHeader.biHeight;
node[i].hotspot.x = 0;
node[i].hotspot.y = 0;
node[i].handbitmap = ImgToAndBitmap( hdc, icon );
node[i].hxorbitmap = ImgToXorBitmap( hdc, icon );
node[i].num_of_images = num_of_images;
node[i].viewhwnd = NULL;
node[i].wrinfo = NULL;
node[i].lnode = NULL;
if( i > 0 ) {
node[i - 1].nexticon = &node[i];
}
node[i].issaved = TRUE;
node[i].next = NULL;
strcpy( node[i].fname, strupr( fname ) );
ImageFini( icon );
}
node[i - 1].nexticon = NULL;
ReleaseDC( NULL, hdc );
ImageClose( iconfile );
fclose( fp );
WriteIconLoadedText( filename, node->num_of_images );
CreateNewDrawPad( node );
MemFree( node );
return( TRUE );
} /* readInIconFile */
ImageError_e Disk2InterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary)
{
FloppyDrive* pDrive = &m_floppyDrive[drive];
FloppyDisk* pFloppy = &pDrive->m_disk;
if (pFloppy->m_imagehandle)
RemoveDisk(drive);
// Reset the disk's attributes, but preserve the drive's attributes (GH#138/Platoon, GH#640)
// . Changing the disk (in the drive) doesn't affect the drive's attributes.
pFloppy->clear();
const DWORD dwAttributes = GetFileAttributes(pszImageFilename);
if(dwAttributes == INVALID_FILE_ATTRIBUTES)
pFloppy->m_bWriteProtected = false; // Assume this is a new file to create
else
pFloppy->m_bWriteProtected = bForceWriteProtected ? true : (dwAttributes & FILE_ATTRIBUTE_READONLY);
// Check if image is being used by the other drive, and if so remove it in order so it can be swapped
{
const char* pszOtherPathname = DiskGetFullPathName(!drive);
char szCurrentPathname[MAX_PATH];
DWORD uNameLen = GetFullPathName(pszImageFilename, MAX_PATH, szCurrentPathname, NULL);
if (uNameLen == 0 || uNameLen >= MAX_PATH)
strcpy_s(szCurrentPathname, MAX_PATH, pszImageFilename);
if (!strcmp(pszOtherPathname, szCurrentPathname))
{
EjectDisk(!drive);
FrameRefreshStatus(DRAW_LEDS | DRAW_BUTTON_DRIVES);
}
}
ImageError_e Error = ImageOpen(pszImageFilename,
&pFloppy->m_imagehandle,
&pFloppy->m_bWriteProtected,
bCreateIfNecessary,
pFloppy->m_strFilenameInZip);
if (Error == eIMAGE_ERROR_NONE && ImageIsMultiFileZip(pFloppy->m_imagehandle))
{
TCHAR szText[100+MAX_PATH];
szText[sizeof(szText)-1] = 0;
_snprintf(szText, sizeof(szText)-1, "Only the first file in a multi-file zip is supported\nUse disk image '%s' ?", pFloppy->m_strFilenameInZip.c_str());
int nRes = MessageBox(g_hFrameWindow, szText, TEXT("Multi-Zip Warning"), MB_ICONWARNING | MB_YESNO | MB_SETFOREGROUND);
if (nRes == IDNO)
{
RemoveDisk(drive);
Error = eIMAGE_ERROR_REJECTED_MULTI_ZIP;
}
}
if (Error == eIMAGE_ERROR_NONE)
{
GetImageTitle(pszImageFilename, pFloppy->m_imagename, pFloppy->m_fullname);
Video_ResetScreenshotCounter(pFloppy->m_imagename);
}
else
{
Video_ResetScreenshotCounter(NULL);
}
SaveLastDiskImage(drive);
return Error;
}