static gboolean read_frame (VFSFile * handle, gint max_size, gint version,
gboolean syncsafe, gint * frame_size, gchar * key, guchar * * data, gint * size)
{
ID3v2FrameHeader header;
gint skip = 0;
if ((max_size -= sizeof (ID3v2FrameHeader)) < 0)
return FALSE;
if (vfs_fread (& header, 1, sizeof (ID3v2FrameHeader), handle) != sizeof
(ID3v2FrameHeader))
return FALSE;
if (! header.key[0]) /* padding */
return FALSE;
header.size = (version == 3) ? GUINT32_FROM_BE (header.size) : unsyncsafe32
(GUINT32_FROM_BE (header.size));
header.flags = GUINT16_FROM_BE (header.flags);
if (header.size > max_size || header.size == 0)
return FALSE;
TAGDBG ("Found frame:\n");
TAGDBG (" key = %.4s\n", header.key);
TAGDBG (" size = %d\n", (gint) header.size);
TAGDBG (" flags = %x\n", (gint) header.flags);
* frame_size = sizeof (ID3v2FrameHeader) + header.size;
sprintf (key, "%.4s", header.key);
if (header.flags & (ID3_FRAME_COMPRESSED | ID3_FRAME_ENCRYPTED))
{
TAGDBG ("Hit compressed/encrypted frame %s.\n", key);
return FALSE;
}
if (header.flags & ID3_FRAME_HAS_GROUP)
skip ++;
if (header.flags & ID3_FRAME_HAS_LENGTH)
skip += 4;
if ((skip > 0 && vfs_fseek (handle, skip, SEEK_CUR)) || skip >= header.size)
return FALSE;
* size = header.size - skip;
* data = g_malloc (* size);
if (vfs_fread (* data, 1, * size, handle) != * size)
return FALSE;
if (syncsafe || (header.flags & ID3_FRAME_SYNCSAFE))
* size = unsyncsafe (* data, * size);
TAGDBG ("Data size = %d.\n", * size);
return TRUE;
}
static int load_module(const char *filename, VFSFile *file, unsigned char *module)
{
int module_len;
if (file != NULL)
return vfs_fread(module, 1, ASAPInfo_MAX_MODULE_LENGTH, file);
file = vfs_fopen(filename, "rb");
if (file == NULL)
return -1;
module_len = vfs_fread(module, 1, ASAPInfo_MAX_MODULE_LENGTH, file);
vfs_fclose(file);
return module_len;
}
static gboolean read_header (VFSFile * handle, gint * version, gboolean *
syncsafe, gsize * offset, gint * header_size, gint * data_size)
{
ID3v2Header header;
if (vfs_fseek (handle, 0, SEEK_SET))
return FALSE;
if (vfs_fread (& header, 1, sizeof (ID3v2Header), handle) != sizeof
(ID3v2Header))
return FALSE;
if (validate_header (& header))
{
* offset = 0;
* version = header.version;
* header_size = sizeof (ID3v2Header);
* data_size = header.size;
} else return FALSE;
* syncsafe = (header.flags & ID3_HEADER_SYNCSAFE) ? TRUE : FALSE;
TAGDBG ("Offset = %d, header size = %d, data size = %d\n",
(gint) * offset, * header_size, * data_size);
return TRUE;
}
static bool_t read_key_raw (ReadState * state, char * * keyp, char * * valp)
{
char * newline = memchr (state->cur, '\n', state->len);
if (! newline)
{
memmove (state->buf, state->cur, state->len);
state->cur = state->buf;
state->len += vfs_fread (state->buf + state->len, 1,
sizeof state->buf - state->len, state->file);
newline = memchr (state->cur, '\n', state->len);
if (! newline)
return FALSE;
}
* newline = 0;
char * equals = strchr (state->cur, '=');
if (! equals)
return FALSE;
* equals = 0;
* keyp = state->cur;
* valp = equals + 1;
state->len -= newline + 1 - state->cur;
state->cur = newline + 1;
return TRUE;
}
static uint32_t mp4_read_callback (void *data, void *buffer, uint32_t len)
{
if (data == NULL || buffer == NULL)
return -1;
return vfs_fread (buffer, 1, len, (VFSFile *) data);
}
gint vtx_is_our_fd(const gchar * filename, VFSFile * fp)
{
gchar buf[2];
if (vfs_fread(buf, 1, 2, fp) < 2)
return FALSE;
return (!strncasecmp(buf, "ay", 2) || !strncasecmp(buf, "ym", 2));
}
w_int RandomAccessFile_readIntoBuffer (JNIEnv *env, w_instance thisRAF, w_instance buffer, w_int offset, w_int length) {
vfs_FILE *file;
w_int result;
w_sbyte *bytes;
w_sbyte *data;
if ((offset < 0) || (offset > instance2Array_length(buffer) - length)) {
throwArrayIndexOutOfBoundsException(JNIEnv2w_thread(env));
return -1;
}
bytes = instance2Array_byte(buffer);
file = RAF2FILE(thisRAF);
if(file == NULL) {
throwNullPointerException(JNIEnv2w_thread(env));
result = 0;
} else {
data = bytes + offset;
result = vfs_fread(data, 1, (w_word)length, file);
if(result == 0) result = -1;
}
return result;
}
gboolean copy_vfs (VFSFile * in, VFSFile * out)
{
if (vfs_fseek (in, 0, SEEK_SET) < 0 || vfs_fseek (out, 0, SEEK_SET) < 0)
return FALSE;
gchar * buffer = g_malloc (COPY_BUF);
gint64 size = 0, readed;
while ((readed = vfs_fread (buffer, 1, COPY_BUF, in)) > 0)
{
if (vfs_fwrite (buffer, 1, readed, out) != readed)
goto FAILED;
size += readed;
}
if (vfs_ftruncate (out, size) < 0)
goto FAILED;
g_free (buffer);
return TRUE;
FAILED:
g_free (buffer);
return FALSE;
}
static size_t read_cb(void *ptr, size_t size, size_t nmemb, FLAC__IOHandle handle)
{
size_t read;
if (handle == NULL)
{
FLACNG_ERROR("Trying to read data from an uninitialized file!\n");
return -1;
}
read = vfs_fread(ptr, size, nmemb, handle);
switch (read)
{
case -1:
FLACNG_ERROR("Error while reading from stream!\n");
return -1;
case 0:
AUDDBG("Stream reached EOF\n");
return 0;
default:
return read;
}
}
FLAC__StreamDecoderReadStatus read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
{
callback_info* info = (callback_info*) client_data;
size_t read;
if (info->fd == NULL)
{
FLACNG_ERROR("Trying to read data from an uninitialized file!\n");
return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
}
if (*bytes == 0)
return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
read = vfs_fread(buffer, 1, *bytes, info->fd);
*bytes = read;
switch (read)
{
case -1:
FLACNG_ERROR("Error while reading from stream!\n");
return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
case 0:
AUDDBG("Stream reached EOF\n");
return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
default:
return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}
}
/**
* Reads an unsigned 64-bit Big Endian value from the stream into native endian format.
*
* @param value Pointer to the variable to read the value into.
* @param stream A #VFSFile object representing the stream.
* @return TRUE if read was succesful, FALSE if there was an error.
*/
EXPORT bool_t vfs_fget_be64(uint64_t *value, VFSFile *stream)
{
uint64_t tmp;
if (vfs_fread(&tmp, sizeof(tmp), 1, stream) != 1)
return FALSE;
*value = GUINT64_FROM_BE(tmp);
return TRUE;
}
/**
* Reads an unsigned 32-bit Little Endian value from the stream into native endian format.
*
* @param value Pointer to the variable to read the value into.
* @param stream A #VFSFile object representing the stream.
* @return TRUE if read was succesful, FALSE if there was an error.
*/
EXPORT bool_t vfs_fget_le32(uint32_t *value, VFSFile *stream)
{
uint32_t tmp;
if (vfs_fread(&tmp, sizeof(tmp), 1, stream) != 1)
return FALSE;
*value = GUINT32_FROM_LE(tmp);
return TRUE;
}
int psf2_is_our_fd(const char *filename, VFSFile *file)
{
uint8 magic[4];
if (vfs_fread(magic, 1, 4, file) < 4)
return FALSE;
return (psf_probe(magic) != ENG_NONE);
}
Index * import_winamp_eqf (VFSFile * file)
{
char header[31];
char bands[11];
int i = 0;
EqualizerPreset *preset = NULL;
char *markup;
char preset_name[0xb4];
if (vfs_fread (header, 1, sizeof header, file) != sizeof header || strncmp
(header, "Winamp EQ library file v1.1", 27))
goto error;
AUDDBG("The EQF header is OK\n");
if (vfs_fseek(file, 0x1f, SEEK_SET) == -1) goto error;
Index * list = index_new ();
while (vfs_fread(preset_name, 1, 0xb4, file) == 0xb4) {
AUDDBG("The preset name is '%s'\n", preset_name);
if (vfs_fseek (file, 0x4d, SEEK_CUR)) /* unknown crap --asphyx */
break;
if (vfs_fread(bands, 1, 11, file) != 11) break;
preset = equalizer_preset_new(preset_name);
/*this was divided by 63, but shouldn't it be 64? --majeru*/
preset->preamp = EQUALIZER_MAX_GAIN - ((bands[10] * EQUALIZER_MAX_GAIN * 2) / 64.0);
for (i = 0; i < 10; i++)
preset->bands[i] = EQUALIZER_MAX_GAIN - ((bands[i] * EQUALIZER_MAX_GAIN * 2) / 64.0);
index_append (list, preset);
}
return list;
error:
markup = g_strdup_printf (_("Error importing Winamp EQF file '%s'"),
vfs_get_filename (file));
interface_show_error(markup);
g_free(markup);
return NULL;
}
static gboolean read_frame (VFSFile * handle, gint max_size, gint version,
gboolean syncsafe, gint * frame_size, gchar * key, guchar * * data, gint * size)
{
ID3v2FrameHeader header;
gint i;
guint32 hdrsz = 0;
if ((max_size -= sizeof (ID3v2FrameHeader)) < 0)
return FALSE;
if (vfs_fread (& header, 1, sizeof (ID3v2FrameHeader), handle) != sizeof
(ID3v2FrameHeader))
return FALSE;
if (! header.key[0]) /* padding */
return FALSE;
for (i = 0; i < 3; i++)
{
hdrsz |= (guint32) header.size[i] << ((2 - i) * 8);
TAGDBG("header.size[%d] = %d hdrsz %d slot %d\n", i, header.size[i], hdrsz, 2 - i);
}
// hdrsz = GUINT32_TO_BE(hdrsz);
if (hdrsz > max_size || hdrsz == 0)
return FALSE;
TAGDBG ("Found frame:\n");
TAGDBG (" key = %.3s\n", header.key);
TAGDBG (" size = %d\n", (gint) hdrsz);
* frame_size = sizeof (ID3v2FrameHeader) + hdrsz;
sprintf (key, "%.3s", header.key);
* size = hdrsz;
* data = g_malloc (* size);
if (vfs_fread (* data, 1, * size, handle) != * size)
return FALSE;
TAGDBG ("Data size = %d.\n", * size);
return TRUE;
}
static void increase_buffer (ProbeBuffer * p, int64_t size)
{
size = (size + 0xFF) & ~0xFF;
if (size > sizeof p->buffer)
size = sizeof p->buffer;
if (p->filled < size)
p->filled += vfs_fread (p->buffer + p->filled, 1, size - p->filled,
p->file);
}
/** Open specified .vtx file and read vtx file header
*
* Open specified .vtx file and read vtx file header in struct vtx
* Return value: true if success, else false
*/
int ayemu_vtx_open (ayemu_vtx_t *vtx, const char *filename)
{
char buf[2];
int error = 0;
int32_t int_regdata_size;
vtx->regdata = NULL;
if ((vtx->fp = vfs_fopen (filename, "rb")) == NULL) {
fprintf(stderr, "ayemu_vtx_open: Cannot open file %s: %s\n", filename, strerror(errno));
return 0;
}
if (vfs_fread(buf, 2, 1, vtx->fp) != 1) {
fprintf(stderr,"ayemu_vtx_open: Can't read from %s: %s\n", filename, strerror(errno));
error = 1;
}
buf[0] = tolower(buf[0]);
buf[1] = tolower(buf[1]);
if (strncmp(buf, "ay", 2) == 0)
vtx->hdr.chiptype = AYEMU_AY;
else if (strncmp (buf, "ym", 2) == 0)
vtx->hdr.chiptype = AYEMU_YM;
else {
fprintf (stderr, "File %s is _not_ VORTEX format!\nIt not begins from AY or YM.\n", filename);
error = 1;
}
/* read VTX header info in order format specified, see http:// ..... */
if (!error) error = read_byte(vtx->fp, &vtx->hdr.stereo);
if (!error) error = read_word16(vtx->fp, &vtx->hdr.loop);
if (!error) error = read_word32(vtx->fp, &vtx->hdr.chipFreq);
if (!error) error = read_byte(vtx->fp, &vtx->hdr.playerFreq);
if (!error) error = read_word16(vtx->fp, &vtx->hdr.year);
if (!error) {
error = read_word32(vtx->fp, &int_regdata_size);
vtx->hdr.regdata_size = (size_t) int_regdata_size;
}
if (!error) error = read_NTstring(vtx->fp, vtx->hdr.title);
if (!error) error = read_NTstring(vtx->fp, vtx->hdr.author);
if (!error) error = read_NTstring(vtx->fp, vtx->hdr.from);
if (!error) error = read_NTstring(vtx->fp, vtx->hdr.tracker);
if (!error) error = read_NTstring (vtx->fp, vtx->hdr.comment);
if (error) {
vfs_fclose(vtx->fp);
vtx->fp = NULL;
}
return !error;
}
EXPORT void vfs_file_read_all (VFSFile * file, void * * bufp, int64_t * sizep)
{
char * buf = NULL;
int64_t size = vfs_fsize (file);
if (size >= 0)
{
size = MIN (size, SIZE_MAX - 1);
buf = malloc (size + 1);
size = vfs_fread (buf, 1, size, file);
}
else
{
size = 0;
size_t bufsize = 4096;
buf = malloc (bufsize);
size_t readsize;
while ((readsize = vfs_fread (buf + size, 1, bufsize - 1 - size, file)))
{
size += readsize;
if (size == bufsize - 1)
{
if (bufsize > SIZE_MAX - 4096)
break;
bufsize += 4096;
buf = realloc (buf, bufsize);
}
}
}
buf[size] = 0; // nul-terminate
* bufp = buf;
if (sizep)
* sizep = size;
}
bool_t flac_is_our_fd(const char *filename, VFSFile *fd)
{
AUDDBG("Probe for FLAC.\n");
if (!fd)
return FALSE;
char buf[4];
if (vfs_fread (buf, 1, sizeof buf, fd) != sizeof buf)
return FALSE;
return ! strncmp (buf, "fLaC", sizeof buf);
}
static char * read_win_text (VFSFile * file)
{
int64_t size = vfs_fsize (file);
if (size < 1)
return NULL;
char * raw = malloc (size + 1);
size = vfs_fread (raw, 1, size, file);
raw[size] = 0;
strip_char (raw, '\r');
char * text = str_to_utf8 (raw);
free (raw);
return text;
}
static gboolean skip_extended_header_3 (VFSFile * handle, gint * _size)
{
guint32 size;
if (vfs_fread (& size, 1, 4, handle) != 4)
return FALSE;
size = GUINT32_FROM_BE (size);
TAGDBG ("Found v2.3 extended header, size = %d.\n", (gint) size);
if (vfs_fseek (handle, size, SEEK_CUR))
return FALSE;
* _size = 4 + size;
return TRUE;
}
w_int RandomAccessFile_read (JNIEnv *env, w_instance thisRAF) {
vfs_FILE *file;
w_int result = -1;
w_sbyte minibuf;
file = RAF2FILE(thisRAF);
if(file == NULL) {
throwNullPointerException(JNIEnv2w_thread(env));
} else {
if (vfs_fread(&minibuf, 1, 1, file) > 0) {
result = minibuf;
}
}
return result;
}
static bool_t skip_extended_header_4 (VFSFile * handle, int * _size)
{
uint32_t size;
if (vfs_fread (& size, 1, 4, handle) != 4)
return FALSE;
size = unsyncsafe32 (GUINT32_FROM_BE (size));
TAGDBG ("Found v2.4 extended header, size = %d.\n", (int) size);
if (vfs_fseek (handle, size - 4, SEEK_CUR))
return FALSE;
* _size = size;
return TRUE;
}
static bool_t vorbis_check_fd (const char * filename, VFSFile * file)
{
ogg_sync_state oy = {0};
ogg_stream_state os = {0};
ogg_page og = {0};
ogg_packet op = {0};
bool_t result = FALSE;
ogg_sync_init (& oy);
while (1)
{
int64_t bytes = ogg_sync_pageseek (& oy, & og);
if (bytes < 0) /* skipped some bytes */
continue;
if (bytes > 0) /* got a page */
break;
void * buffer = ogg_sync_buffer (& oy, 2048);
bytes = vfs_fread (buffer, 1, 2048, file);
if (bytes <= 0)
goto end;
ogg_sync_wrote (& oy, bytes);
}
if (! ogg_page_bos (& og))
goto end;
ogg_stream_init (& os, ogg_page_serialno (& og));
ogg_stream_pagein (& os, & og);
if (ogg_stream_packetout (& os, & op) > 0 && vorbis_synthesis_idheader (& op))
result = TRUE;
end:
ogg_sync_clear (& oy);
ogg_stream_clear (& os);
return result;
}
static AVInputFormat * get_format_by_content (const gchar * name, VFSFile * file)
{
AUDDBG ("Get format by content: %s\n", name);
AVInputFormat * f = NULL;
guchar buf[16384 + AVPROBE_PADDING_SIZE];
gint size = 16;
gint filled = 0;
gint target = 100;
gint score = 0;
while (1)
{
if (filled < size)
filled += vfs_fread (buf + filled, 1, size - filled, file);
memset (buf + filled, 0, AVPROBE_PADDING_SIZE);
AVProbeData d = {name, buf, filled};
score = target;
f = av_probe_input_format2 (& d, TRUE, & score);
if (f)
break;
if (size < 16384 && filled == size)
size *= 4;
else if (target > 10)
target = 10;
else
break;
}
if (f)
AUDDBG ("Format %s, buffer size %d, score %d.\n", f->name, filled, score);
else
AUDDBG ("Format unknown.\n");
if (vfs_fseek (file, 0, SEEK_SET) < 0)
; /* ignore errors here */
return f;
}
static size_t read_vfs(VFSSTREAMFILE *streamfile, uint8_t *dest, off_t offset, size_t length)
{
size_t sz;
// if the offsets don't match, then we need to perform a seek
if (streamfile->offset != offset)
{
if (vfs_fseek(streamfile->vfsFile, offset, SEEK_SET) < 0)
return 0;
streamfile->offset = offset;
}
sz = vfs_fread(dest, 1, length, streamfile->vfsFile);
// increment our current offset
if (sz >= 0)
streamfile->offset += sz;
return sz;
}
static void increase_buffer (ProbeBuffer * p, gint64 size)
{
size = (size + 0xFF) & ~0xFF;
if (size > sizeof p->buffer)
{
if (p->read_warned != p->decoder)
{
fprintf (stderr, "%s tried to read past end of buffer while "
"probing %s.\n", p->decoder, p->filename);
p->read_warned = p->decoder;
}
size = sizeof p->buffer;
}
if (p->filled < size)
p->filled += vfs_fread (p->buffer + p->filled, 1, size - p->filled,
p->file);
}
gchar * load_text_file (const gchar * filename)
{
VFSFile * file;
gint size;
gchar * buffer;
file = vfs_fopen (filename, "r");
if (file == NULL)
return NULL;
size = vfs_fsize (file);
size = MAX (0, size);
buffer = g_malloc (size + 1);
size = vfs_fread (buffer, 1, size, file);
size = MAX (0, size);
buffer[size] = 0;
vfs_fclose (file);
return buffer;
}
static size_t ovcb_read (void * buffer, size_t size, size_t count, void * file)
{
return vfs_fread (buffer, size, count, file);
}
static gint read_cb (void * file, gchar * buf, gint len)
{
return vfs_fread (buf, 1, len, file);
}
