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); }