int RGBE_ReadPixels_Raw(NvFile *fp, unsigned char *data, int numpixels)
{
if (NvFRead(data, 4, numpixels, fp) < (size_t)numpixels)
return rgbe_error(rgbe_read_error,NULL);
return RGBE_RETURN_SUCCESS;
}
// loads 24-bit bmp files into 32-bit RGBA texture
unsigned int *LoadBMP(char const *name, int *width, int *height)
{
NvFile *f = NvFOpen(name);
if (f == 0)
{
LOGW("error opening %s!\n", name);
return 0;
}
BITMAP_HEADER head;
BMPV3_INFO_HEADER info;
NvFRead(&head, sizeof(BITMAP_HEADER), 1, f);
NvFRead(&info, sizeof(BMPV3_INFO_HEADER), 1, f);
NvFSeek(f, head.bitmapPtr, SEEK_SET);
*width = info.bWidth;
*height = info.bHeight;
uint *imageData = new uint[info.bWidth * info.bHeight];
int scanSize = (info.bWidth * (info.bBpp >> 3) + 3) & ~0x3;
uchar *rdata = new uchar[scanSize];
for (int y = info.bHeight - 1; y >= 0; y--)
{
NvFRead(rdata, scanSize, 1, f);
// shuffle rgb
int index = y * info.bWidth;
for (int i = 0; i < info.bWidth; i++)
{
imageData[index + i] = (rdata[i * 3] << 16)
| (rdata[i * 3 + 1] << 8) | rdata[i * 3 + 2] | 0xff000000;
}
}
NvFClose(f);
delete[] rdata;
LOGI("loaded %ix%i input image", info.bWidth, info.bHeight);
return imageData;
}
/* simple read routine. will not correctly handle run length encoding */
int RGBE_ReadPixels(NvFile *fp, float *data, int numpixels)
{
unsigned char rgbe[4];
while(numpixels-- > 0) {
if (NvFRead(rgbe, sizeof(rgbe), 1, fp) < 1)
return rgbe_error(rgbe_read_error,NULL);
rgbe2float(&data[RGBE_DATA_RED],&data[RGBE_DATA_GREEN],
&data[RGBE_DATA_BLUE],rgbe);
data += RGBE_DATA_SIZE;
}
return RGBE_RETURN_SUCCESS;
}
void* cBinaryFile::GetDataFile(UINT e_uiStart)
{
if(!m_pData)
{
if( !m_pFile )
return 0;
long l_lFileSize = UT::GetFileSize(this->m_pFile);
if( l_lFileSize == 0 )
return 0;
m_pData = new char[l_lFileSize];
NvFRead(m_pData,sizeof(char),l_lFileSize,m_pFile);
}
char*l_pOutPutData = m_pData;
l_pOutPutData += e_uiStart;
return (void*)l_pOutPutData;
}
int RGBE_ReadPixels_Raw_RLE(NvFile *fp, unsigned char *data, int scanline_width,
int num_scanlines)
{
unsigned char rgbe[4], *scanline_buffer, *ptr, *ptr_end;
int i, count;
unsigned char buf[2];
if ((scanline_width < 8)||(scanline_width > 0x7fff))
/* run length encoding is not allowed so read flat*/
return RGBE_ReadPixels_Raw(fp,data,scanline_width*num_scanlines);
scanline_buffer = NULL;
/* read in each successive scanline */
while(num_scanlines > 0) {
if (NvFRead(rgbe,sizeof(rgbe),1,fp) < 1) {
free(scanline_buffer);
return rgbe_error(rgbe_read_error,NULL);
}
if ((rgbe[0] != 2)||(rgbe[1] != 2)||(rgbe[2] & 0x80)) {
/* this file is not run length encoded */
data[0] = rgbe[0];
data[1] = rgbe[1];
data[2] = rgbe[2];
data[3] = rgbe[3];
data += RGBE_DATA_SIZE;
free(scanline_buffer);
return RGBE_ReadPixels_Raw(fp,data,scanline_width*num_scanlines-1);
}
if ((((int)rgbe[2])<<8 | rgbe[3]) != scanline_width) {
free(scanline_buffer);
return rgbe_error(rgbe_format_error,(char*)"wrong scanline width");
}
if (scanline_buffer == NULL)
scanline_buffer = (unsigned char *) malloc(sizeof(unsigned char)*4*scanline_width);
if (scanline_buffer == NULL)
return rgbe_error(rgbe_memory_error,(char*)"unable to allocate buffer space");
ptr = &scanline_buffer[0];
/* read each of the four channels for the scanline into the buffer */
for(i=0;i<4;i++) {
ptr_end = &scanline_buffer[(i+1)*scanline_width];
while(ptr < ptr_end) {
if (NvFRead(buf,sizeof(buf[0])*2,1,fp) < 1) {
free(scanline_buffer);
return rgbe_error(rgbe_read_error,NULL);
}
if (buf[0] > 128) {
/* a run of the same value */
count = buf[0]-128;
if ((count == 0)||(count > ptr_end - ptr)) {
free(scanline_buffer);
return rgbe_error(rgbe_format_error,(char*)"bad scanline data");
}
while(count-- > 0)
*ptr++ = buf[1];
}
else {
/* a non-run */
count = buf[0];
if ((count == 0)||(count > ptr_end - ptr)) {
free(scanline_buffer);
return rgbe_error(rgbe_format_error,(char*)"bad scanline data");
}
*ptr++ = buf[1];
if (--count > 0) {
if (NvFRead(ptr,sizeof(*ptr)*count,1,fp) < 1) {
free(scanline_buffer);
return rgbe_error(rgbe_read_error,NULL);
}
ptr += count;
}
}
}
}
/* copy byte data to output */
for(i=0;i<scanline_width;i++) {
data[0] = scanline_buffer[i];
data[1] = scanline_buffer[i+scanline_width];
data[2] = scanline_buffer[i+2*scanline_width];
data[3] = scanline_buffer[i+3*scanline_width];
data += 4;
}
num_scanlines--;
}
free(scanline_buffer);
return RGBE_RETURN_SUCCESS;
}
size_t MMfread(void * ptr, size_t size, size_t nmemb, MMFILE * stream)
{
return NvFRead(ptr, size, nmemb, (NvFile*)stream);
}
size_t crRead(void* buff, size_t elsize, size_t nelem, void* handle)
{
return NvFRead(buff, elsize, nelem, (NvFile*)handle);
}
