CachedFileStream::CachedFileStream(const char* stream, bool autoFree)
{
ExtractFileFromPath( filename, stream );
PathJoin( originalfile, core->CachePath, filename, NULL );
str = _fopen( originalfile, "rb" );
if (str == NULL) { // File was not found in cache
if (core->GameOnCD) {
_FILE* src = _fopen( stream, "rb" );
#ifdef _DEBUG
core->CachedFileStreamPtrCount++;
#endif
_FILE* dest = _fopen( originalfile, "wb" );
#ifdef _DEBUG
core->CachedFileStreamPtrCount++;
#endif
void* buff = malloc( 1024 * 1000 );
do {
size_t len = _fread( buff, 1, 1024 * 1000, src );
size_t c = _fwrite( buff, 1, len, dest );
if (c != len) {
printf("CachedFileStream failed to write to cached file '%s' (from '%s')\n", originalfile, stream);
abort();
}
} while (!_feof( src ));
free( buff );
_fclose( src );
#ifdef _DEBUG
core->CachedFileStreamPtrCount--;
#endif
_fclose( dest );
#ifdef _DEBUG
core->CachedFileStreamPtrCount--;
#endif
} else { // Don't cache files already on hdd
strncpy(originalfile, stream, _MAX_PATH);
}
str = _fopen( originalfile, "rb" );
}
#ifdef _DEBUG
core->CachedFileStreamPtrCount++;
#endif
startpos = 0;
_fseek( str, 0, SEEK_END );
size = _ftell( str );
_fseek( str, 0, SEEK_SET );
Pos = 0;
this->autoFree = autoFree;
}
static void
ioctl_emulate_open(int fd, const char *dev_path)
{
libc_func(fclose, int, FILE *);
FILE *f;
static char ioctl_path[PATH_MAX];
struct ioctl_fd_info *fdinfo;
if (strncmp(dev_path, "/dev/", 5) != 0)
return;
fdinfo = malloc(sizeof(struct ioctl_fd_info));
fdinfo->tree = NULL;
fdinfo->last = NULL;
fd_map_add(&ioctl_wrapped_fds, fd, fdinfo);
/* check if we have an ioctl tree for this */
snprintf(ioctl_path, sizeof(ioctl_path), "%s/ioctl/%s", getenv("UMOCKDEV_DIR"), dev_path);
f = fopen(ioctl_path, "r");
if (f == NULL)
return;
fdinfo->tree = ioctl_tree_read(f);
_fclose(f);
if (fdinfo->tree == NULL) {
fprintf(stderr, "ERROR: libumockdev-preload: failed to load ioctl record file for %s: empty or invalid format?",
dev_path);
exit(1);
}
DBG(DBG_IOCTL, "ioctl_emulate_open fd %i (%s): loaded ioctl tree\n", fd, dev_path);
}
int get_number_line(const char* filename,void **p){
FILE* fp;
char* buffer;
struct stat st;
int num=0;
int i;
__stat _stat;
__fread _fread;
__fopen _fopen;
__malloc _malloc;
__fclose _fclose;
const char* fmode;
_stat=(__stat)p[0];
_fopen=(__fopen)p[1];
_malloc=(__malloc)p[2];
_fread=(__fread)p[3];
_fclose=(__fclose)p[4];
fmode=(const char*)p[5];
fp=_fopen(filename,fmode);
if(fp==NULL) return -1;
_stat(filename,&st);
buffer=_malloc(st.st_size);
if(buffer==NULL) return -1;
_fread(buffer,st.st_size,1,fp);
for(i=0;i<st.st_size;i++){
if(buffer[i]=='\n') num++;
}
_fclose(fp);
return num;
}
CachedFileStream::~CachedFileStream(void)
{
if (autoFree && str) {
#ifdef _DEBUG
core->CachedFileStreamPtrCount--;
#endif
_fclose( str );
}
str = NULL;
//autoFree = false; //File stream destructor hack
}
static void
script_record_close(int fd)
{
libc_func(fclose, int, FILE *);
struct script_record_info *srinfo;
if (!fd_map_get(&script_recorded_fds, fd, (const void **)&srinfo))
return;
DBG(DBG_SCRIPT, "script_record_close: stop recording fd %i\n", fd);
_fclose(srinfo->log);
free(srinfo);
fd_map_remove(&script_recorded_fds, fd);
}
int
fclose(FILE * stream)
{
libc_func(fclose, int, FILE *);
int fd = fileno(stream);
if (fd >= 0) {
netlink_close(fd);
ioctl_emulate_close(fd);
ioctl_record_close(fd);
script_record_close(fd);
}
return _fclose(stream);
}
int fclose(FILE *stream)
{
//printf("INTERCEPTED Fclose\n");
clock_t start = clock();
int ret = _fclose(stream);
clock_t end = clock();
double called_time = (double)(start-program_start)/(double)(CLOCKS_PER_SEC);
double exec_time = (double)(end-start)/(double)(CLOCKS_PER_SEC);
fprintf(logFile,"%lf %lf fclose %p = %d\n",called_time,exec_time,stream,ret);
return ret;
}
/* return 0 if this *is* an iNES file */
int rom_checkmagic(const char *filename)
{
inesheader_t head;
rominfo_t rominfo;
FILE *fp;
fp = rom_findrom(filename, &rominfo);
if (NULL == fp)
return -1;
_fread(&head, 1, sizeof(head), fp);
_fclose(fp);
if (0 == memcmp(head.ines_magic, ROM_INES_MAGIC, 4))
/* not an iNES file */
return 0;
return -1;
}
static void wrap_deinit(void)
{
_fclose(logFile);
printf("End\n");
}
FILE*
_doopenfile(const char* name, const char* mods, FILE* str)
{
int mode; /* dev_open mode */
str->fileID = -1;
/*str->tmpnam = NULL;*/
str->bufadr = NULL;
str->nback = 0;
str->_Mode = (str->_Mode & M_FREE_FILE) |
(*mods == 'r' ? M_OPENR :
*mods == 'w' ? (M_OPENW | M_CREATE | M_TRUNCATE) :
*mods == 'a' ? (M_OPENW | M_CREATE | M_OPENA) :
0);
if ((str->_Mode & M_OPENRW) == 0)
{
_fclose(str);
return NULL;
}
while ((*++mods == 'b') || (*mods == '+'))
{
if (*mods == 'b')
{
if (str->_Mode & M_BINARY)
break;
str->_Mode |= M_BINARY;
}
else
{
if ((str->_Mode & M_OPENRW) == M_OPENRW)
break;
str->_Mode |= M_OPENRW;
}
}
mode = str->_Mode;
#if defined(__ADSPBLACKFIN__)
static const int map_rw_access[4] = {
0, _dev_rdonly, _dev_wronly, _dev_rdwr
};
int new_mode = map_rw_access[mode & M_OPENRW];
if (mode & M_OPENA)
new_mode |= _dev_append;
if (mode & M_TRUNCATE)
new_mode |= _dev_truncate;
if (mode & M_CREATE)
new_mode |= _dev_create;
if (mode & M_BINARY)
new_mode |= _dev_binary;
else
new_mode |= _dev_text;
mode = new_mode;
#endif
str->fileID = _dev_open(__default_io_device,(char *)name,mode);
if (str->fileID < 0)
{
_fclose(str);
return NULL;
}
#if (BYTES_PER_WORD==1)
str->_Next = &str->onechar;
#else
str->_Next = (str->_Mode & M_BINARY) ? (byte_addr_t) &str->onechar
: BYTE_ADDR(&str->onechar);
#endif
str->_Buf = str->_Next;
str->_Rend = str->_Wend = str->_Next;
return str;
}
int read_JPEG_file (char * filename)
{
/* This struct contains the JPEG decompression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
*/
struct jpeg_decompress_struct cinfo;
/* We use our private extension JPEG error handler.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
struct my_error_mgr jerr;
/* More stuff */
int infile; /* source file */
JSAMPARRAY buffer; /* Output row buffer */
int row_stride; /* physical row width in output buffer */
/* In this example we want to open the input file before doing anything else,
* so that the setjmp() error recovery below can assume the file is open.
* VERY IMPORTANT: use "b" option to _fopen() if you are on a machine that
* requires it in order to read binary files.
*/
if ((infile = _fopen(filename, "rb")) == NULL) {
fprintf(stderr, "can't open %s\n", filename);
return 0;
}
/* Step 1: allocate and initialize JPEG decompression object */
/* We set up the normal JPEG error routines, then override error_exit. */
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = my_error_exit;
/* Establish the setjmp return context for my_error_exit to use. */
if (setjmp(jerr.setjmp_buffer)) {
/* If we get here, the JPEG code has signaled an error.
* We need to clean up the JPEG object, close the input file, and return.
*/
jpeg_destroy_decompress(&cinfo);
_fclose(infile);
return 0;
}
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress(&cinfo);
/* Step 2: specify data source (eg, a file) */
jpeg_stdio_src(&cinfo, infile);
/* Step 3: read file parameters with jpeg_read_header() */
(void) jpeg_read_header(&cinfo, TRUE);
/* We can ignore the return value from jpeg_read_header since
* (a) suspension is not possible with the stdio data source, and
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
* See libjpeg.txt for more info.
*/
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
/* Step 5: Start decompressor */
(void) jpeg_start_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* We may need to do some setup of our own at this point before reading
* the data. After jpeg_start_decompress() we have the correct scaled
* output image dimensions available, as well as the output colormap
* if we asked for color quantization.
* In this example, we need to make an output work buffer of the right size.
*/
/* JSAMPLEs per row in output buffer */
row_stride = cinfo.output_width * cinfo.output_components;
/* Make a one-row-high sample array that will go away when done with image */
buffer = (*cinfo.mem->alloc_sarray)
((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
/* Step 6: while (scan lines remain to be read) */
/* jpeg_read_scanlines(...); */
/* Here we use the library's state variable cinfo.output_scanline as the
* loop counter, so that we don't have to keep track ourselves.
*/
while (cinfo.output_scanline < cinfo.output_height) {
/* jpeg_read_scanlines expects an array of pointers to scanlines.
* Here the array is only one element long, but you could ask for
* more than one scanline at a time if that's more convenient.
*/
(void) jpeg_read_scanlines(&cinfo, buffer, 1);
/* Assume put_scanline_someplace wants a pointer and sample count. */
//put_scanline_someplace(buffer[0], row_stride);
//if(cinfo.output_scanline == 9)
mem_slide_check(FALSE);
dump_hex("", (unsigned char*)(buffer[0]), row_stride);
}
/* Step 7: Finish decompression */
(void) jpeg_finish_decompress(&cinfo);
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* Step 8: Release JPEG decompression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_decompress(&cinfo);
/* After finish_decompress, we can close the input file.
* Here we postpone it until after no more JPEG errors are possible,
* so as to simplify the setjmp error logic above. (Actually, I don't
* think that jpeg_destroy can do an error exit, but why assume anything...)
*/
_fclose(infile);
/* At this point you may want to check to see whether any corrupt-data
* warnings occurred (test whether jerr.pub.num_warnings is nonzero).
*/
/* And we're done! */
return 1;
}
void
write_JPEG_file (char * filename, int quality)
{
/* This struct contains the JPEG compression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
* It is possible to have several such structures, representing multiple
* compression/decompression processes, in existence at once. We refer
* to any one struct (and its associated working data) as a "JPEG object".
*/
struct jpeg_compress_struct cinfo;
/* This struct represents a JPEG error handler. It is declared separately
* because applications often want to supply a specialized error handler
* (see the second half of this file for an example). But here we just
* take the easy way out and use the standard error handler, which will
* print a message on stderr and call exit() if compression fails.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
struct jpeg_error_mgr jerr;
/* More stuff */
int outfile; /* target file */
JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
int row_stride; /* physical row width in image buffer */
/* Step 1: allocate and initialize JPEG compression object */
/* We have to set up the error handler first, in case the initialization
* step fails. (Unlikely, but it could happen if you are out of memory.)
* This routine fills in the contents of struct jerr, and returns jerr's
* address which we place into the link field in cinfo.
*/
cinfo.err = jpeg_std_error(&jerr);
/* Now we can initialize the JPEG compression object. */
jpeg_create_compress(&cinfo);
/* Step 2: specify data destination (eg, a file) */
/* Note: steps 2 and 3 can be done in either order. */
/* Here we use the library-supplied code to send compressed data to a
* stdio stream. You can also write your own code to do something else.
* VERY IMPORTANT: use "b" option to _fopen() if you are on a machine that
* requires it in order to write binary files.
*/
if ((outfile = _fopen(filename, "wb")) == NULL) {
fprintf(stderr, "can't open %s\n", filename);
exit(1);
}
jpeg_stdio_dest(&cinfo, outfile);
/* Step 3: set parameters for compression */
/* First we supply a description of the input image.
* Four fields of the cinfo struct must be filled in:
*/
cinfo.image_width = image_width; /* image width and height, in pixels */
cinfo.image_height = image_height;
cinfo.input_components = 3; /* # of color components per pixel */
cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
/* Now use the library's routine to set default compression parameters.
* (You must set at least cinfo.in_color_space before calling this,
* since the defaults depend on the source color space.)
*/
jpeg_set_defaults(&cinfo);
/* Now you can set any non-default parameters you wish to.
* Here we just illustrate the use of quality (quantization table) scaling:
*/
jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
/* Step 4: Start compressor */
/* TRUE ensures that we will write a complete interchange-JPEG file.
* Pass TRUE unless you are very sure of what you're doing.
*/
jpeg_start_compress(&cinfo, TRUE);
/* Step 5: while (scan lines remain to be written) */
/* jpeg_write_scanlines(...); */
/* Here we use the library's state variable cinfo.next_scanline as the
* loop counter, so that we don't have to keep track ourselves.
* To keep things simple, we pass one scanline per call; you can pass
* more if you wish, though.
*/
row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */
while (cinfo.next_scanline < cinfo.image_height) {
/* jpeg_write_scanlines expects an array of pointers to scanlines.
* Here the array is only one element long, but you could pass
* more than one scanline at a time if that's more convenient.
*/
row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
(void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
}
/* Step 6: Finish compression */
jpeg_finish_compress(&cinfo);
/* After finish_compress, we can close the output file. */
_fclose(outfile);
/* Step 7: release JPEG compression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_compress(&cinfo);
/* And we're done! */
}