Cool_Tools/vgmstream
1
0
Fork 0
mirror of https://github.com/vgmstream/vgmstream.git synced 2025-01-31 12:23:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup

Browse Source
This commit is contained in:
bnnm 2020-07-18 00:27:53 +02:00
parent 5ecf1136a3
commit c728301989
4 changed files with 96 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/coding/acm_decoder.c
View File

@ -16,7 +16,6 @@ static int acm_get_length_streamfile(void* arg);
acm_codec_data* init_acm(STREAMFILE* sf, int force_channel_number) { acm_codec_data* init_acm(STREAMFILE* sf, int force_channel_number) {
acm_codec_data* data = NULL; acm_codec_data* data = NULL;
char filename[PATH_LIMIT];
data = calloc(1,sizeof(acm_codec_data)); data = calloc(1,sizeof(acm_codec_data));
@ -25,8 +24,7 @@ acm_codec_data* init_acm(STREAMFILE* sf, int force_channel_number) {
data->io_config = calloc(1,sizeof(acm_io_config)); data->io_config = calloc(1,sizeof(acm_io_config));
if (!data->io_config) goto fail; if (!data->io_config) goto fail;
get_streamfile_name(sf, filename, sizeof(filename)); data->streamfile = reopen_streamfile(sf, 0);
data->streamfile = open_streamfile(sf,filename);
if (!data->streamfile) goto fail; if (!data->streamfile) goto fail;
/* Setup libacm decoder, needs read callbacks and a parameter for said callbacks */ /* Setup libacm decoder, needs read callbacks and a parameter for said callbacks */

4
src/coding/hca_decoder.c
View File

@ -19,7 +19,6 @@ struct hca_codec_data {
/* init a HCA stream; STREAMFILE will be duplicated for internal use. */ /* init a HCA stream; STREAMFILE will be duplicated for internal use. */
hca_codec_data* init_hca(STREAMFILE* sf) { hca_codec_data* init_hca(STREAMFILE* sf) {
char filename[PATH_LIMIT];
uint8_t header_buffer[0x2000]; /* hca header buffer data (probable max ~0x400) */ uint8_t header_buffer[0x2000]; /* hca header buffer data (probable max ~0x400) */
hca_codec_data* data = NULL; /* vgmstream HCA context */ hca_codec_data* data = NULL; /* vgmstream HCA context */
int header_size; int header_size;
@ -55,8 +54,7 @@ hca_codec_data* init_hca(STREAMFILE* sf) {
if (!data->sample_buffer) goto fail; if (!data->sample_buffer) goto fail;
/* load streamfile for reads */ /* load streamfile for reads */
get_streamfile_name(sf,filename, sizeof(filename)); data->streamfile = reopen_streamfile(sf, 0);
data->streamfile = open_streamfile(sf,filename);
if (!data->streamfile) goto fail; if (!data->streamfile) goto fail;
/* set initial values */ /* set initial values */

10
src/coding/nwa_decoder.c
View File

@ -396,8 +396,7 @@ void decode_nwa(nwa_codec_data* data, sample_t* outbuf, int32_t samples_to_do) {
nwa_codec_data* init_nwa(STREAMFILE* sf) { nwa_codec_data* init_nwa(STREAMFILE* sf) {
nwa_codec_data *data = NULL; nwa_codec_data* data = NULL;
char filename[PATH_LIMIT];
data = malloc(sizeof(nwa_codec_data)); data = malloc(sizeof(nwa_codec_data));
if (!data) goto fail; if (!data) goto fail;
@ -405,8 +404,7 @@ nwa_codec_data* init_nwa(STREAMFILE* sf) {
data->nwa = nwalib_open(sf); data->nwa = nwalib_open(sf);
if (!data->nwa) goto fail; if (!data->nwa) goto fail;
get_streamfile_name(sf,filename,sizeof(filename)); data->sf = reopen_streamfile(sf, 0);
data->sf = open_streamfile(sf, filename);
if (!data->sf) goto fail; if (!data->sf) goto fail;
return data; return data;
@ -416,13 +414,13 @@ fail:
return NULL; return NULL;
} }
void seek_nwa(nwa_codec_data *data, int32_t sample) { void seek_nwa(nwa_codec_data* data, int32_t sample) {
if (!data) return; if (!data) return;
nwalib_seek(data->sf, data->nwa, sample); nwalib_seek(data->sf, data->nwa, sample);
} }
void reset_nwa(nwa_codec_data *data) { void reset_nwa(nwa_codec_data* data) {
if (!data) return; if (!data) return;
nwalib_reset(data->nwa); nwalib_reset(data->nwa);

180
src/streamfile.h
View File

@ -65,13 +65,13 @@
* to do file operations, as plugins may need to provide their own callbacks. * to do file operations, as plugins may need to provide their own callbacks.
* Reads from arbitrary offsets, meaning internally may need fseek equivalents during reads. */ * Reads from arbitrary offsets, meaning internally may need fseek equivalents during reads. */
typedef struct _STREAMFILE { typedef struct _STREAMFILE {
size_t (*read)(struct _STREAMFILE *, uint8_t * dst, off_t offset, size_t length); size_t (*read)(struct _STREAMFILE*, uint8_t* dst, off_t offset, size_t length);
size_t (*get_size)(struct _STREAMFILE *); size_t (*get_size)(struct _STREAMFILE*);
off_t (*get_offset)(struct _STREAMFILE *); //todo: DO NOT USE, NOT RESET PROPERLY (remove?) off_t (*get_offset)(struct _STREAMFILE*); //todo: DO NOT USE, NOT RESET PROPERLY (remove?)
/* for dual-file support */ /* for dual-file support */
void (*get_name)(struct _STREAMFILE * ,char *name, size_t length); void (*get_name)(struct _STREAMFILE*, char* name, size_t length);
struct _STREAMFILE * (*open)(struct _STREAMFILE *, const char * const filename, size_t buffersize); struct _STREAMFILE* (*open)(struct _STREAMFILE*, const char* const filename, size_t buffersize);
void (*close)(struct _STREAMFILE *); void (*close)(struct _STREAMFILE*);
/* Substream selection for files with subsongs. Manually used in metas if supported. /* Substream selection for files with subsongs. Manually used in metas if supported.
@ -86,152 +86,152 @@ typedef struct _STREAMFILE {
/* Opens a standard STREAMFILE, opening from path. /* Opens a standard STREAMFILE, opening from path.
* Uses stdio (FILE) for operations, thus plugins may not want to use it. */ * Uses stdio (FILE) for operations, thus plugins may not want to use it. */
STREAMFILE* open_stdio_streamfile(const char *filename); STREAMFILE* open_stdio_streamfile(const char* filename);
/* Opens a standard STREAMFILE from a pre-opened FILE. */ /* Opens a standard STREAMFILE from a pre-opened FILE. */
STREAMFILE* open_stdio_streamfile_by_file(FILE *file, const char *filename); STREAMFILE* open_stdio_streamfile_by_file(FILE* file, const char* filename);
/* Opens a STREAMFILE that does buffered IO. /* Opens a STREAMFILE that does buffered IO.
* Can be used when the underlying IO may be slow (like when using custom IO). * Can be used when the underlying IO may be slow (like when using custom IO).
* Buffer size is optional. */ * Buffer size is optional. */
STREAMFILE* open_buffer_streamfile(STREAMFILE *streamfile, size_t buffer_size); STREAMFILE* open_buffer_streamfile(STREAMFILE* sf, size_t buffer_size);
STREAMFILE* open_buffer_streamfile_f(STREAMFILE *streamfile, size_t buffer_size); STREAMFILE* open_buffer_streamfile_f(STREAMFILE* sf, size_t buffer_size);
/* Opens a STREAMFILE that doesn't close the underlying streamfile. /* Opens a STREAMFILE that doesn't close the underlying streamfile.
* Calls to open won't wrap the new SF (assumes it needs to be closed). * Calls to open won't wrap the new SF (assumes it needs to be closed).
* Can be used in metas to test custom IO without closing the external SF. */ * Can be used in metas to test custom IO without closing the external SF. */
STREAMFILE* open_wrap_streamfile(STREAMFILE *streamfile); STREAMFILE* open_wrap_streamfile(STREAMFILE* sf);
STREAMFILE* open_wrap_streamfile_f(STREAMFILE *streamfile); STREAMFILE* open_wrap_streamfile_f(STREAMFILE* sf);
/* Opens a STREAMFILE that clamps reads to a section of a larger streamfile. /* Opens a STREAMFILE that clamps reads to a section of a larger streamfile.
* Can be used with subfiles inside a bigger file (to fool metas, or to simplify custom IO). */ * Can be used with subfiles inside a bigger file (to fool metas, or to simplify custom IO). */
STREAMFILE* open_clamp_streamfile(STREAMFILE *streamfile, off_t start, size_t size); STREAMFILE* open_clamp_streamfile(STREAMFILE* sf, off_t start, size_t size);
STREAMFILE* open_clamp_streamfile_f(STREAMFILE *streamfile, off_t start, size_t size); STREAMFILE* open_clamp_streamfile_f(STREAMFILE* sf, off_t start, size_t size);
/* Opens a STREAMFILE that uses custom IO for streamfile reads. /* Opens a STREAMFILE that uses custom IO for streamfile reads.
* Can be used to modify data on the fly (ex. decryption), or even transform it from a format to another. * Can be used to modify data on the fly (ex. decryption), or even transform it from a format to another.
* Data is an optional state struct of some size what will be malloc+copied on open. */ * Data is an optional state struct of some size what will be malloc+copied on open. */
STREAMFILE* open_io_streamfile(STREAMFILE *streamfile, void *data, size_t data_size, void *read_callback, void *size_callback); STREAMFILE* open_io_streamfile(STREAMFILE* sf, void* data, size_t data_size, void* read_callback, void* size_callback);
STREAMFILE* open_io_streamfile_f(STREAMFILE *streamfile, void *data, size_t data_size, void *read_callback, void *size_callback); STREAMFILE* open_io_streamfile_f(STREAMFILE* sf, void* data, size_t data_size, void* read_callback, void* size_callback);
/* Same, but calls init on SF open and close on close, when malloc/free is needed. /* Same, but calls init on SF open and close on close, when malloc/free is needed.
* Data struct may be used to hold malloc'd pointers and stuff. */ * Data struct may be used to hold malloc'd pointers and stuff. */
STREAMFILE* open_io_streamfile_ex(STREAMFILE *streamfile, void *data, size_t data_size, void *read_callback, void *size_callback, void* init_callback, void* close_callback); STREAMFILE* open_io_streamfile_ex(STREAMFILE* sf, void* data, size_t data_size, void* read_callback, void* size_callback, void* init_callback, void* close_callback);
STREAMFILE* open_io_streamfile_ex_f(STREAMFILE *streamfile, void *data, size_t data_size, void *read_callback, void *size_callback, void* init_callback, void* close_callback); STREAMFILE* open_io_streamfile_ex_f(STREAMFILE* sf, void* data, size_t data_size, void* read_callback, void* size_callback, void* init_callback, void* close_callback);
/* Opens a STREAMFILE that reports a fake name, but still re-opens itself properly. /* Opens a STREAMFILE that reports a fake name, but still re-opens itself properly.
* Can be used to trick a meta's extension check (to call from another, with a modified SF). * Can be used to trick a meta's extension check (to call from another, with a modified SF).
* When fakename isn't supplied it's read from the streamfile, and the extension swapped with fakeext. * When fakename isn't supplied it's read from the streamfile, and the extension swapped with fakeext.
* If the fakename is an existing file, open won't work on it as it'll reopen the fake-named streamfile. */ * If the fakename is an existing file, open won't work on it as it'll reopen the fake-named streamfile. */
STREAMFILE* open_fakename_streamfile(STREAMFILE *streamfile, const char * fakename, const char * fakeext); STREAMFILE* open_fakename_streamfile(STREAMFILE* sf, const char* fakename, const char* fakeext);
STREAMFILE* open_fakename_streamfile_f(STREAMFILE *streamfile, const char * fakename, const char * fakeext); STREAMFILE* open_fakename_streamfile_f(STREAMFILE* sf, const char* fakename, const char* fakeext);
/* Opens streamfile formed from multiple streamfiles, their data joined during reads. /* Opens streamfile formed from multiple streamfiles, their data joined during reads.
* Can be used when data is segmented in multiple separate files. * Can be used when data is segmented in multiple separate files.
* The first streamfile is used to get names, stream index and so on. */ * The first streamfile is used to get names, stream index and so on. */
STREAMFILE* open_multifile_streamfile(STREAMFILE **streamfiles, size_t streamfiles_size); STREAMFILE* open_multifile_streamfile(STREAMFILE** sfs, size_t sfs_size);
STREAMFILE* open_multifile_streamfile_f(STREAMFILE **streamfiles, size_t streamfiles_size); STREAMFILE* open_multifile_streamfile_f(STREAMFILE** sfs, size_t sfs_size);
/* Opens a STREAMFILE from a (path)+filename. /* Opens a STREAMFILE from a (path)+filename.
* Just a wrapper, to avoid having to access the STREAMFILE's callbacks directly. */ * Just a wrapper, to avoid having to access the STREAMFILE's callbacks directly. */
STREAMFILE* open_streamfile(STREAMFILE *streamfile, const char * pathname); STREAMFILE* open_streamfile(STREAMFILE* sf, const char* pathname);
/* Opens a STREAMFILE from a base pathname + new extension /* Opens a STREAMFILE from a base pathname + new extension
* Can be used to get companion headers. */ * Can be used to get companion headers. */
STREAMFILE* open_streamfile_by_ext(STREAMFILE *streamfile, const char * ext); STREAMFILE* open_streamfile_by_ext(STREAMFILE* sf, const char* ext);
/* Opens a STREAMFILE from a base path + new filename. /* Opens a STREAMFILE from a base path + new filename.
* Can be used to get companion files. Relative paths like * Can be used to get companion files. Relative paths like
* './filename', '../filename', 'dir/filename' also work. */ * './filename', '../filename', 'dir/filename' also work. */
STREAMFILE* open_streamfile_by_filename(STREAMFILE *streamfile, const char * filename); STREAMFILE* open_streamfile_by_filename(STREAMFILE* sf, const char* filename);
/* Reopen a STREAMFILE with a different buffer size, for fine-tuned bigfile parsing. /* Reopen a STREAMFILE with a different buffer size, for fine-tuned bigfile parsing.
* Uses default buffer size when buffer_size is 0 */ * Uses default buffer size when buffer_size is 0 */
STREAMFILE * reopen_streamfile(STREAMFILE *streamfile, size_t buffer_size); STREAMFILE* reopen_streamfile(STREAMFILE* sf, size_t buffer_size);
/* close a file, destroy the STREAMFILE object */ /* close a file, destroy the STREAMFILE object */
static inline void close_streamfile(STREAMFILE * streamfile) { static inline void close_streamfile(STREAMFILE* sf) {
if (streamfile!=NULL) if (sf != NULL)
streamfile->close(streamfile); sf->close(sf);
} }
/* read from a file, returns number of bytes read */ /* read from a file, returns number of bytes read */
static inline size_t read_streamfile(uint8_t *dst, off_t offset, size_t length, STREAMFILE *streamfile) { static inline size_t read_streamfile(uint8_t *dst, off_t offset, size_t length, STREAMFILE* sf) {
return streamfile->read(streamfile, dst, offset,length); return sf->read(sf, dst, offset,length);
} }
/* return file size */ /* return file size */
static inline size_t get_streamfile_size(STREAMFILE * streamfile) { static inline size_t get_streamfile_size(STREAMFILE* sf) {
return streamfile->get_size(streamfile); return sf->get_size(sf);
} }
/* Sometimes you just need an int, and we're doing the buffering. /* Sometimes you just need an int, and we're doing the buffering.
* Note, however, that if these fail to read they'll return -1, * Note, however, that if these fail to read they'll return -1,
* so that should not be a valid value or there should be some backup. */ * so that should not be a valid value or there should be some backup. */
static inline int16_t read_16bitLE(off_t offset, STREAMFILE * streamfile) { static inline int16_t read_16bitLE(off_t offset, STREAMFILE* sf) {
uint8_t buf[2]; uint8_t buf[2];
if (read_streamfile(buf,offset,2,streamfile)!=2) return -1; if (read_streamfile(buf,offset,2,sf)!=2) return -1;
return get_16bitLE(buf); return get_16bitLE(buf);
} }
static inline int16_t read_16bitBE(off_t offset, STREAMFILE * streamfile) { static inline int16_t read_16bitBE(off_t offset, STREAMFILE* sf) {
uint8_t buf[2]; uint8_t buf[2];
if (read_streamfile(buf,offset,2,streamfile)!=2) return -1; if (read_streamfile(buf,offset,2,sf)!=2) return -1;
return get_16bitBE(buf); return get_16bitBE(buf);
} }
static inline int32_t read_32bitLE(off_t offset, STREAMFILE * streamfile) { static inline int32_t read_32bitLE(off_t offset, STREAMFILE* sf) {
uint8_t buf[4]; uint8_t buf[4];
if (read_streamfile(buf,offset,4,streamfile)!=4) return -1; if (read_streamfile(buf,offset,4,sf)!=4) return -1;
return get_32bitLE(buf); return get_32bitLE(buf);
} }
static inline int32_t read_32bitBE(off_t offset, STREAMFILE * streamfile) { static inline int32_t read_32bitBE(off_t offset, STREAMFILE* sf) {
uint8_t buf[4]; uint8_t buf[4];
if (read_streamfile(buf,offset,4,streamfile)!=4) return -1; if (read_streamfile(buf,offset,4,sf)!=4) return -1;
return get_32bitBE(buf); return get_32bitBE(buf);
} }
static inline int64_t read_64bitLE(off_t offset, STREAMFILE * streamfile) { static inline int64_t read_64bitLE(off_t offset, STREAMFILE* sf) {
uint8_t buf[8]; uint8_t buf[8];
if (read_streamfile(buf,offset,8,streamfile)!=8) return -1; if (read_streamfile(buf,offset,8,sf)!=8) return -1;
return get_64bitLE(buf); return get_64bitLE(buf);
} }
static inline int64_t read_64bitBE(off_t offset, STREAMFILE * streamfile) { static inline int64_t read_64bitBE(off_t offset, STREAMFILE* sf) {
uint8_t buf[8]; uint8_t buf[8];
if (read_streamfile(buf,offset,8,streamfile)!=8) return -1; if (read_streamfile(buf,offset,8,sf)!=8) return -1;
return get_64bitBE(buf); return get_64bitBE(buf);
} }
static inline int8_t read_8bit(off_t offset, STREAMFILE * streamfile) { static inline int8_t read_8bit(off_t offset, STREAMFILE* sf) {
uint8_t buf[1]; uint8_t buf[1];
if (read_streamfile(buf,offset,1,streamfile)!=1) return -1; if (read_streamfile(buf,offset,1,sf)!=1) return -1;
return buf[0]; return buf[0];
} }
/* alias of the above */ /* alias of the above */
static inline int8_t read_s8 (off_t offset, STREAMFILE *sf) { return read_8bit(offset, sf); } static inline int8_t read_s8 (off_t offset, STREAMFILE* sf) { return read_8bit(offset, sf); }
static inline uint8_t read_u8 (off_t offset, STREAMFILE *sf) { return (uint8_t) read_8bit(offset, sf); } static inline uint8_t read_u8 (off_t offset, STREAMFILE* sf) { return (uint8_t) read_8bit(offset, sf); }
static inline int16_t read_s16le(off_t offset, STREAMFILE *sf) { return read_16bitLE(offset, sf); } static inline int16_t read_s16le(off_t offset, STREAMFILE* sf) { return read_16bitLE(offset, sf); }
static inline uint16_t read_u16le(off_t offset, STREAMFILE *sf) { return (uint16_t)read_16bitLE(offset, sf); } static inline uint16_t read_u16le(off_t offset, STREAMFILE* sf) { return (uint16_t)read_16bitLE(offset, sf); }
static inline int16_t read_s16be(off_t offset, STREAMFILE *sf) { return read_16bitBE(offset, sf); } static inline int16_t read_s16be(off_t offset, STREAMFILE* sf) { return read_16bitBE(offset, sf); }
static inline uint16_t read_u16be(off_t offset, STREAMFILE *sf) { return (uint16_t)read_16bitBE(offset, sf); } static inline uint16_t read_u16be(off_t offset, STREAMFILE* sf) { return (uint16_t)read_16bitBE(offset, sf); }
static inline int32_t read_s32le(off_t offset, STREAMFILE *sf) { return read_32bitLE(offset, sf); } static inline int32_t read_s32le(off_t offset, STREAMFILE* sf) { return read_32bitLE(offset, sf); }
static inline uint32_t read_u32le(off_t offset, STREAMFILE *sf) { return (uint32_t)read_32bitLE(offset, sf); } static inline uint32_t read_u32le(off_t offset, STREAMFILE* sf) { return (uint32_t)read_32bitLE(offset, sf); }
static inline int32_t read_s32be(off_t offset, STREAMFILE *sf) { return read_32bitBE(offset, sf); } static inline int32_t read_s32be(off_t offset, STREAMFILE* sf) { return read_32bitBE(offset, sf); }
static inline uint32_t read_u32be(off_t offset, STREAMFILE *sf) { return (uint32_t)read_32bitBE(offset, sf); } static inline uint32_t read_u32be(off_t offset, STREAMFILE* sf) { return (uint32_t)read_32bitBE(offset, sf); }
static inline int64_t read_s64be(off_t offset, STREAMFILE *sf) { return read_64bitBE(offset, sf); } static inline int64_t read_s64be(off_t offset, STREAMFILE* sf) { return read_64bitBE(offset, sf); }
static inline uint64_t read_u64be(off_t offset, STREAMFILE *sf) { return (uint64_t)read_64bitBE(offset, sf); } static inline uint64_t read_u64be(off_t offset, STREAMFILE* sf) { return (uint64_t)read_64bitBE(offset, sf); }
static inline int64_t read_s64le(off_t offset, STREAMFILE *sf) { return read_64bitLE(offset, sf); } static inline int64_t read_s64le(off_t offset, STREAMFILE* sf) { return read_64bitLE(offset, sf); }
static inline uint64_t read_u64le(off_t offset, STREAMFILE *sf) { return (uint64_t)read_64bitLE(offset, sf); } static inline uint64_t read_u64le(off_t offset, STREAMFILE* sf) { return (uint64_t)read_64bitLE(offset, sf); }
/* The recommended int-to-float type punning in C is through union, but pointer casting /* The recommended int-to-float type punning in C is through union, but pointer casting
* works too (though less portable due to aliasing rules?). For C++ memcpy seems * works too (though less portable due to aliasing rules?). For C++ memcpy seems
* recommended. Both work in GCC and VS2015+ (not sure about older, ifdef as needed). */ * recommended. Both work in GCC and VS2015+ (not sure about older, ifdef as needed). */
static inline float read_f32be(off_t offset, STREAMFILE *sf) { static inline float read_f32be(off_t offset, STREAMFILE* sf) {
union { union {
uint32_t u32; uint32_t u32;
float f32; float f32;
@ -239,7 +239,7 @@ static inline float read_f32be(off_t offset, STREAMFILE *sf) {
temp.u32 = read_u32be(offset, sf); temp.u32 = read_u32be(offset, sf);
return temp.f32; return temp.f32;
} }
static inline float read_f32le(off_t offset, STREAMFILE * sf) { static inline float read_f32le(off_t offset, STREAMFILE* sf) {
union { union {
uint32_t u32; uint32_t u32;
float f32; float f32;
@ -248,12 +248,12 @@ static inline float read_f32le(off_t offset, STREAMFILE * sf) {
return temp.f32; return temp.f32;
} }
#if 0 #if 0
static inline float read_f32be_p(off_t offset, STREAMFILE *sf) { static inline float read_f32be_p(off_t offset, STREAMFILE* sf) {
uint32_t sample_int = read_u32be(offset, sf); uint32_t sample_int = read_u32be(offset, sf);
float* sample_float = (float*)&sample_int; float* sample_float = (float*)&sample_int;
return *sample_float; return *sample_float;
} }
static inline float read_f32be_m(off_t offset, STREAMFILE *sf) { static inline float read_f32be_m(off_t offset, STREAMFILE* sf) {
uint32_t sample_int = read_u32be(offset, sf); uint32_t sample_int = read_u32be(offset, sf);
float sample_float; float sample_float;
memcpy(&sample_float, &sample_int, sizeof(uint32_t)); memcpy(&sample_float, &sample_int, sizeof(uint32_t));
@ -288,18 +288,18 @@ void sf_reader_init(sf_reader *r, int big_endian) {
*/ */
#endif #endif
#if 0 //todo improve + test + simplify code (maybe not inline?) #if 0 //todo improve + test + simplify code (maybe not inline?)
static inline int read_s4h(off_t offset, STREAMFILE * streamfile) { static inline int read_s4h(off_t offset, STREAMFILE* sf) {
uint8_t byte = read_u8(offset, streamfile); uint8_t byte = read_u8(offset, streamfile);
return get_nibble_signed(byte, 1); return get_nibble_signed(byte, 1);
} }
static inline int read_u4h(off_t offset, STREAMFILE * streamfile) { static inline int read_u4h(off_t offset, STREAMFILE* sf) {
uint8_t byte = read_u8(offset, streamfile); uint8_t byte = read_u8(offset, streamfile);
return (byte >> 4) & 0x0f; return (byte >> 4) & 0x0f;
} }
static inline int read_s4l(off_t offset, STREAMFILE * streamfile) { static inline int read_s4l(off_t offset, STREAMFILE* sf) {
... ...
} }
static inline int read_u4l(off_t offset, STREAMFILE * streamfile) { static inline int read_u4l(off_t offset, STREAMFILE* sf) {
... ...
} }
static inline int max_s32(int32_t a, int32_t b) { return a > b ? a : b; } static inline int max_s32(int32_t a, int32_t b) { return a > b ? a : b; }
@ -309,14 +309,14 @@ static inline int min_s32(int32_t a, int32_t b) { return a < b ? a : b; }
//TODO: maybe move to streamfile.c //TODO: maybe move to streamfile.c
/* guess byte endianness from a given value, return true if big endian and false if little endian */ /* guess byte endianness from a given value, return true if big endian and false if little endian */
static inline int guess_endianness16bit(off_t offset, STREAMFILE * streamfile) { static inline int guess_endianness16bit(off_t offset, STREAMFILE* sf) {
uint8_t buf[0x02]; uint8_t buf[0x02];
if (read_streamfile(buf,offset,0x02,streamfile) != 0x02) return -1; /* ? */ if (read_streamfile(buf, offset, 0x02, sf) != 0x02) return -1; /* ? */
return (uint16_t)get_16bitLE(buf) > (uint16_t)get_16bitBE(buf) ? 1 : 0; return (uint16_t)get_16bitLE(buf) > (uint16_t)get_16bitBE(buf) ? 1 : 0;
} }
static inline int guess_endianness32bit(off_t offset, STREAMFILE * streamfile) { static inline int guess_endianness32bit(off_t offset, STREAMFILE* sf) {
uint8_t buf[0x04]; uint8_t buf[0x04];
if (read_streamfile(buf,offset,0x04,streamfile) != 0x04) return -1; /* ? */ if (read_streamfile(buf, offset, 0x04, sf) != 0x04) return -1; /* ? */
return (uint32_t)get_32bitLE(buf) > (uint32_t)get_32bitBE(buf) ? 1 : 0; return (uint32_t)get_32bitLE(buf) > (uint32_t)get_32bitBE(buf) ? 1 : 0;
} }
@ -331,10 +331,10 @@ static inline size_t align_size_to_block(size_t value, size_t block_align) {
/* Read into dst a line delimited by CRLF (Windows) / LF (Unux) / CR (Mac) / EOF, null-terminated /* Read into dst a line delimited by CRLF (Windows) / LF (Unux) / CR (Mac) / EOF, null-terminated
* and without line feeds. Returns bytes read (including CR/LF), *not* the same as string length. * and without line feeds. Returns bytes read (including CR/LF), *not* the same as string length.
* p_line_ok is set to 1 if the complete line was read; pass NULL to ignore. */ * p_line_ok is set to 1 if the complete line was read; pass NULL to ignore. */
size_t read_line(char *buf, int buf_size, off_t offset, STREAMFILE *sf, int *p_line_ok); size_t read_line(char* buf, int buf_size, off_t offset, STREAMFILE* sf, int* p_line_ok);
/* reads a c-string (ANSI only), up to bufsize or NULL, returning size. buf is optional (works as get_string_size). */ /* reads a c-string (ANSI only), up to bufsize or NULL, returning size. buf is optional (works as get_string_size). */
size_t read_string(char *buf, size_t buf_size, off_t offset, STREAMFILE *sf); size_t read_string(char* buf, size_t buf_size, off_t offset, STREAMFILE* sf);
/* reads a UTF16 string... but actually only as ANSI (discards the upper byte) */ /* reads a UTF16 string... but actually only as ANSI (discards the upper byte) */
size_t read_string_utf16(char* buf, size_t buf_size, off_t offset, STREAMFILE* sf, int big_endian); size_t read_string_utf16(char* buf, size_t buf_size, off_t offset, STREAMFILE* sf, int big_endian);
size_t read_string_utf16le(char* buf, size_t buf_size, off_t offset, STREAMFILE* sf); size_t read_string_utf16le(char* buf, size_t buf_size, off_t offset, STREAMFILE* sf);
@ -343,31 +343,31 @@ size_t read_string_utf16be(char* buf, size_t buf_size, off_t offset, STREAMFILE*
/* Opens a file containing decryption keys and copies to buffer. /* Opens a file containing decryption keys and copies to buffer.
* Tries "(name.ext)key" (per song), "(.ext)key" (per folder) keynames. * Tries "(name.ext)key" (per song), "(.ext)key" (per folder) keynames.
* returns size of key if found and copied */ * returns size of key if found and copied */
size_t read_key_file(uint8_t *buf, size_t buf_size, STREAMFILE *sf); size_t read_key_file(uint8_t* buf, size_t buf_size, STREAMFILE* sf);
/* hack to allow relative paths in various OSs */ /* hack to allow relative paths in various OSs */
void fix_dir_separators(char *filename); void fix_dir_separators(char* filename);
/* Checks if the stream filename is one of the extensions (comma-separated, ex. "adx" or "adx,aix"). /* Checks if the stream filename is one of the extensions (comma-separated, ex. "adx" or "adx,aix").
* Empty is ok to accept files without extension ("", "adx,,aix"). Returns 0 on failure */ * Empty is ok to accept files without extension ("", "adx,,aix"). Returns 0 on failure */
int check_extensions(STREAMFILE *streamFile, const char * cmp_exts); int check_extensions(STREAMFILE* sf, const char* cmp_exts);
/* chunk-style file helpers */ /* chunk-style file helpers */
int find_chunk_be(STREAMFILE *streamFile, uint32_t chunk_id, off_t start_offset, int full_chunk_size, off_t *out_chunk_offset, size_t *out_chunk_size); int find_chunk_be(STREAMFILE* sf, uint32_t chunk_id, off_t start_offset, int full_chunk_size, off_t* p_chunk_offset, size_t* p_chunk_size);
int find_chunk_le(STREAMFILE *streamFile, uint32_t chunk_id, off_t start_offset, int full_chunk_size, off_t *out_chunk_offset, size_t *out_chunk_size); int find_chunk_le(STREAMFILE* sf, uint32_t chunk_id, off_t start_offset, int full_chunk_size, off_t* p_chunk_offset, size_t* p_chunk_size);
int find_chunk(STREAMFILE *streamFile, uint32_t chunk_id, off_t start_offset, int full_chunk_size, off_t *out_chunk_offset, size_t *out_chunk_size, int big_endian_size, int zero_size_end); int find_chunk(STREAMFILE* sf, uint32_t chunk_id, off_t start_offset, int full_chunk_size, off_t* p_chunk_offset, size_t* p_chunk_size, int big_endian_size, int zero_size_end);
/* find a RIFF-style chunk (with chunk_size not including id and size) */ /* find a RIFF-style chunk (with chunk_size not including id and size) */
int find_chunk_riff_le(STREAMFILE *streamFile, uint32_t chunk_id, off_t start_offset, size_t max_size, off_t *out_chunk_offset, size_t *out_chunk_size); int find_chunk_riff_le(STREAMFILE* sf, uint32_t chunk_id, off_t start_offset, size_t max_size, off_t* p_chunk_offset, size_t* p_chunk_size);
int find_chunk_riff_be(STREAMFILE *streamFile, uint32_t chunk_id, off_t start_offset, size_t max_size, off_t *out_chunk_offset, size_t *out_chunk_size); int find_chunk_riff_be(STREAMFILE* sf, uint32_t chunk_id, off_t start_offset, size_t max_size, off_t* p_chunk_offset, size_t* p_chunk_size);
/* same with chunk ids in variable endianess (so instead of "fmt " has " tmf" */ /* same with chunk ids in variable endianess (so instead of "fmt " has " tmf" */
int find_chunk_riff_ve(STREAMFILE *streamFile, uint32_t chunk_id, off_t start_offset, size_t max_size, off_t *out_chunk_offset, size_t *out_chunk_size, int big_endian); int find_chunk_riff_ve(STREAMFILE* sf, uint32_t chunk_id, off_t start_offset, size_t max_size, off_t* p_chunk_offset, size_t* p_chunk_size, int big_endian);
/* filename helpers */ /* filename helpers */
void get_streamfile_name(STREAMFILE *streamFile, char * buffer, size_t size); void get_streamfile_name(STREAMFILE* sf, char* buf, size_t size);
void get_streamfile_filename(STREAMFILE *streamFile, char * buffer, size_t size); void get_streamfile_filename(STREAMFILE* sf, char* buf, size_t size);
void get_streamfile_basename(STREAMFILE *streamFile, char * buffer, size_t size); void get_streamfile_basename(STREAMFILE* sf, char* buf, size_t size);
void get_streamfile_path(STREAMFILE *streamFile, char * buffer, size_t size); void get_streamfile_path(STREAMFILE* sf, char* buf, size_t size);
void get_streamfile_ext(STREAMFILE *streamFile, char * filename, size_t size); void get_streamfile_ext(STREAMFILE* sf, char* buf, size_t size);
void dump_streamfile(STREAMFILE *streamFile, int num); void dump_streamfile(STREAMFILE* sf, int num);
#endif #endif