virtual int scanf_one(const char *fmt, void* val) {
std::string buffer;
char element = 0;
bool bDone = false;
if(substream) return substream->scanf_one(fmt,val);
do {
if(_io->read_proc(&element, 1, 1, _handle) == 1) {
switch(element) {
case '0':
case '\n':
case ' ':
case '\t':
bDone = true;
break;
default:
break;
}
buffer.append(&element, 1);
} else {
return 0;
}
} while(!bDone);
return sscanf(buffer.c_str(), fmt, val);
}
/**
Reads data from a memory stream
@param buffer Storage location for data
@param size Item size in bytes
@param count Maximum number of items to be read
@param stream Pointer to FIMEMORY structure
@return Returns the number of full items actually read, which may be less than count if an error occurs
*/
unsigned DLL_CALLCONV
FreeImage_ReadMemory(void *buffer, unsigned size, unsigned count, FIMEMORY *stream) {
FreeImageIO io;
SetMemoryIO(&io);
if (stream != NULL) {
return io.read_proc(buffer, size, count, stream);
}
return 0;
}
virtual char* gets(char *buffer, int length) {
if (substream) return substream->gets(buffer, length);
memset(buffer, 0, length);
for(int i = 0; i < length; i++) {
if(!_io->read_proc(&buffer[i], 1, 1, _handle))
return NULL;
if(buffer[i] == 0x0A)
break;
}
return buffer;
}
virtual int get_char() {
int c = 0;
if(substream) return substream->get_char();
if(!_io->read_proc(&c, 1, 1, _handle)) return -1;
return c;
}
virtual int read(void *buffer, size_t size, size_t count) {
if(substream) return substream->read(buffer, size, count);
return _io->read_proc(buffer, (unsigned)size, (unsigned)count, _handle);
}
bool
C_IStream::read (char c[/*n*/], int n) {
return ((unsigned)n != _io->read_proc(c, 1, n, _handle));
}
static WORD
readline(FreeImageIO &io, fi_handle handle, BYTE *buffer, WORD length, BOOL rle, BYTE * ReadBuf, int * ReadPos) {
// -----------------------------------------------------------//
// Read either run-length encoded or normal image data //
// //
// THIS IS HOW RUNTIME LENGTH ENCODING WORKS IN PCX: //
// //
// 1) If the upper 2 bits of a byte are set, //
// the lower 6 bits specify the count for the next byte //
// //
// 2) If the upper 2 bits of the byte are clear, //
// the byte is actual data with a count of 1 //
// //
// Note that a scanline always has an even number of bytes //
// -------------------------------------------------------------
BYTE count = 0, value = 0;
WORD written = 0;
if (rle) {
// run-length encoded read
while (length--) {
if (count == 0) {
if (*ReadPos >= IO_BUF_SIZE - 1 ) {
if (*ReadPos == IO_BUF_SIZE - 1) {
// we still have one BYTE, copy it to the start pos
*ReadBuf = ReadBuf[IO_BUF_SIZE - 1];
io.read_proc(ReadBuf + 1, 1, IO_BUF_SIZE - 1, handle);
} else {
// read the complete buffer
io.read_proc(ReadBuf, 1, IO_BUF_SIZE, handle);
}
*ReadPos = 0;
}
value = *(ReadBuf + (*ReadPos)++);
if ((value & 0xC0) == 0xC0) {
count = value & 0x3F;
value = *(ReadBuf + (*ReadPos)++); // $JR
} else {
count = 1;
}
}
count--;
*(buffer + written++) = value;
}
} else {
// normal read
written = (WORD)io.read_proc(buffer, length, 1, handle);
}
return written;
}
virtual bool read (char c[/*n*/], int n) {
return ((unsigned)n != _io->read_proc(c, 1, n, _handle));
}