static gboolean save_winamp_file (const gchar * filename)
{
VFSFile *file;
gchar name[257];
gint i;
guchar bands[11];
if (!(file = open_vfs_file(filename, "wb")))
return FALSE;
if (vfs_fwrite ("Winamp EQ library file v1.1\x1a!--", 1, 31, file) != 31)
goto ERR;
memset(name, 0, 257);
g_strlcpy(name, "Entry1", 257);
if (vfs_fwrite (name, 1, 257, file) != 257)
goto ERR;
for (i = 0; i < AUD_EQUALIZER_NBANDS; i++)
bands[i] = 63 - (((equalizerwin_get_band(i) + EQUALIZER_MAX_GAIN) * 63) / EQUALIZER_MAX_GAIN / 2);
bands[AUD_EQUALIZER_NBANDS] = 63 - (((equalizerwin_get_preamp() + EQUALIZER_MAX_GAIN) * 63) / EQUALIZER_MAX_GAIN / 2);
if (vfs_fwrite (bands, 1, 11, file) != 11)
goto ERR;
vfs_fclose (file);
return TRUE;
ERR:
vfs_fclose (file);
return FALSE;
}
bool_t save_preset_file (EqualizerPreset * preset, const char * filename)
{
GKeyFile *rcfile;
int i;
char *data;
gsize len;
GError *error = NULL;
rcfile = g_key_file_new();
g_key_file_set_double(rcfile, "Equalizer preset", "Preamp", preset->preamp);
for (i = 0; i < 10; i++) {
char tmp[7];
g_snprintf(tmp, sizeof(tmp), "Band%d", i);
g_key_file_set_double(rcfile, "Equalizer preset", tmp,
preset->bands[i]);
}
data = g_key_file_to_data(rcfile, &len, &error);
bool_t success = FALSE;
VFSFile * file = vfs_fopen (filename, "w");
if (file == NULL)
goto DONE;
if (vfs_fwrite (data, 1, strlen (data), file) == strlen (data))
success = TRUE;
vfs_fclose (file);
DONE:
g_free(data);
g_key_file_free(rcfile);
return success;
}
gboolean write_and_pivot_files (vcedit_state * state)
{
gchar * temp;
GError * error;
gint handle = g_file_open_tmp (NULL, & temp, & error);
if (handle < 0)
{
fprintf (stderr, "Failed to create temp file: %s.\n", error->message);
g_error_free (error);
return FALSE;
}
close (handle);
gchar * temp_uri = filename_to_uri (temp);
g_return_val_if_fail (temp_uri, FALSE);
VFSFile * temp_vfs = vfs_fopen (temp_uri, "r+");
g_return_val_if_fail (temp_vfs, FALSE);
str_unref (temp_uri);
if (vcedit_write (state, temp_vfs) < 0)
{
fprintf (stderr, "Tag update failed: %s.\n", state->lasterror);
vfs_fclose (temp_vfs);
g_free (temp);
return FALSE;
}
if (! copy_vfs (temp_vfs, state->in))
{
fprintf (stderr, "Failed to copy temp file. The temp file has not "
"been deleted: %s.\n", temp);
vfs_fclose (temp_vfs);
g_free (temp);
return FALSE;
}
vfs_fclose (temp_vfs);
if (g_unlink (temp) < 0)
fprintf (stderr, "Failed to delete temp file: %s.\n", temp);
g_free (temp);
return TRUE;
}
static int probe_buffer_fclose (VFSFile * file)
{
ProbeBuffer * p = vfs_get_handle (file);
int ret = vfs_fclose (p->file);
g_slice_free (ProbeBuffer, p);
return ret;
}
LIBMTP_track_t *track_metadata(Tuple *from_tuple)
{
LIBMTP_track_t *tr;
gchar *filename, *uri_path;
VFSFile *f;
uint64_t filesize;
struct stat sb;
uri_path = strdup_tuple_filename (from_tuple);
gchar *tmp = g_strescape(uri_path,NULL);
filename=g_filename_from_uri(tmp,NULL,NULL);
g_free(tmp);
/* dealing the stream upload (invalidating)*/
if(filename)
{
f = vfs_fopen(uri_path,"r");
g_free(uri_path);
if(vfs_is_streaming(f))
{
vfs_fclose(f);
g_free(filename);
return NULL;
}
}
else
{
g_print("Warning! the filename is NULL, exiting");
return NULL;
}
if ( stat(filename, &sb) == -1 )
{
#if DEBUG
g_print("ERROR! encountered while stat()'ing \"%s\"\n",filename);
#endif
g_free(filename);
return NULL;
}
filesize = (uint64_t) sb.st_size;
/* track metadata*/
tr = LIBMTP_new_track_t();
tr->title = strdup_tuple_field (from_tuple, FIELD_TITLE);
tr->artist = strdup_tuple_field (from_tuple, FIELD_ARTIST);
tr->album = strdup_tuple_field (from_tuple, FIELD_ALBUM);
tr->filesize = filesize;
tr->filename = strdup_tuple_field (from_tuple, FIELD_FILE_NAME);
tr->duration = (uint32_t)tuple_get_int(from_tuple, FIELD_LENGTH, NULL);
tr->filetype = find_filetype (filename);
tr->genre = strdup_tuple_field (from_tuple, FIELD_GENRE);
tr->date = strdup_tuple_field (from_tuple, FIELD_YEAR);
g_free(filename);
return tr;
}
static void
load_winamp_file(const gchar * filename)
{
VFSFile *file;
if (!(file = open_vfs_file(filename, "rb")))
return;
equalizerwin_read_winamp_eqf(file);
vfs_fclose(file);
}
/** Free all of allocaded resource for this file.
*
* Free the unpacket register data if is and close file.
*/
void ayemu_vtx_free (ayemu_vtx_t *vtx)
{
if (vtx->fp) {
vfs_fclose(vtx->fp);
vtx->fp = NULL;
}
if (vtx->regdata) {
free(vtx->regdata);
vtx->regdata = NULL;
}
}
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;
}
/** 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;
}
/** Read and encode lha data from .vtx file
*
* Return value: pointer to unpacked data or NULL
* Note: you must call ayemu_vtx_open() first.
*/
char *ayemu_vtx_load_data (ayemu_vtx_t *vtx)
{
char *packed_data;
size_t packed_size;
size_t buf_alloc;
int c;
if (vtx->fp == NULL) {
fprintf(stderr, "ayemu_vtx_load_data: tune file not open yet (do you call ayemu_vtx_open first?)\n");
return NULL;
}
packed_size = 0;
buf_alloc = 4096;
packed_data = (char *) malloc (buf_alloc);
/* read packed AY register data to end of file. */
while ((c = vfs_getc (vtx->fp)) != EOF) {
if (buf_alloc < packed_size) {
buf_alloc *= 2;
packed_data = (char *) realloc (packed_data, buf_alloc);
if (packed_data == NULL) {
fprintf (stderr, "ayemu_vtx_load_data: Packed data out of memory!\n");
vfs_fclose (vtx->fp);
return NULL;
}
}
packed_data[packed_size++] = c;
}
vfs_fclose (vtx->fp);
vtx->fp = NULL;
if ((vtx->regdata = (char *) malloc (vtx->hdr.regdata_size)) == NULL) {
fprintf (stderr, "ayemu_vtx_load_data: Can allocate %d bytes for unpack register data\n", (int)(vtx->hdr.regdata_size));
free (packed_data);
return NULL;
}
lh5_decode ((unsigned char *)packed_data, (unsigned char *)(vtx->regdata), vtx->hdr.regdata_size, packed_size);
free (packed_data);
vtx->pos = 0;
return vtx->regdata;
}
/**
* Gets contents of the file into a buffer. Buffer of filesize bytes
* is allocated by this function as necessary.
*
* @param filename URI of the file to read in.
* @param buf Pointer to a pointer variable of buffer.
* @param size Pointer to gsize variable that will hold the amount of
* read data e.g. filesize.
*/
EXPORT void vfs_file_get_contents (const char * filename, void * * buf, int64_t * size)
{
* buf = NULL;
if (size)
* size = 0;
VFSFile * file = vfs_fopen (filename, "r");
if (! file)
return;
vfs_file_read_all (file, buf, size);
vfs_fclose (file);
}
bool_t playlist_save (int list, const char * filename)
{
AUDDBG ("Saving playlist %s.\n", filename);
PluginHandle * plugin = get_plugin (filename, TRUE);
if (! plugin)
return FALSE;
PlaylistPlugin * pp = plugin_get_header (plugin);
g_return_val_if_fail (pp && PLUGIN_HAS_FUNC (pp, load), FALSE);
bool_t fast = get_bool (NULL, "metadata_on_play");
VFSFile * file = vfs_fopen (filename, "w");
if (! file)
return FALSE;
char * title = playlist_get_title (list);
int entries = playlist_entry_count (list);
Index * filenames = index_new ();
index_allocate (filenames, entries);
Index * tuples = index_new ();
index_allocate (tuples, entries);
for (int i = 0; i < entries; i ++)
{
index_append (filenames, playlist_entry_get_filename (list, i));
index_append (tuples, playlist_entry_get_tuple (list, i, fast));
}
bool_t success = pp->save (filename, file, title, filenames, tuples);
vfs_fclose (file);
str_unref (title);
for (int i = 0; i < entries; i ++)
{
str_unref (index_get (filenames, i));
Tuple * tuple = index_get (tuples, i);
if (tuple)
tuple_unref (tuple);
}
index_free (filenames);
index_free (tuples);
return success;
}
static void file_close(void)
{
plugin->close();
convert_free();
if (output_file != NULL)
vfs_fclose(output_file);
output_file = NULL;
if (tuple)
{
tuple_unref (tuple);
tuple = NULL;
}
}
static gboolean save_winamp_file (const gchar * filename)
{
VFSFile *file;
if (!(file = open_vfs_file(filename, "wb")))
return FALSE;
EqualizerPreset * preset = aud_equalizer_preset_new ("Preset1");
equalizerwin_update_preset (preset);
bool_t success = aud_export_winamp_preset (preset, file);
aud_equalizer_preset_free (preset);
vfs_fclose (file);
return success;
}
static void * playback_thread (void * unused)
{
PluginHandle * p = playback_entry_get_decoder ();
current_decoder = p ? plugin_get_header (p) : NULL;
if (! current_decoder)
{
char * error = g_strdup_printf (_("No decoder found for %s."),
current_filename);
interface_show_error (error);
g_free (error);
playback_error = TRUE;
goto DONE;
}
current_data = NULL;
current_bitrate = 0;
current_samplerate = 0;
current_channels = 0;
Tuple * tuple = playback_entry_get_tuple ();
read_gain_from_tuple (tuple);
if (tuple)
tuple_unref (tuple);
bool_t seekable = (playback_entry_get_length () > 0);
VFSFile * file = vfs_fopen (current_filename, "r");
time_offset = seekable ? playback_entry_get_start_time () : 0;
playback_error = ! current_decoder->play (& playback_api, current_filename,
file, seekable ? time_offset + initial_seek : 0,
seekable ? playback_entry_get_end_time () : -1, paused);
output_close_audio ();
if (file)
vfs_fclose (file);
DONE:
if (! ready_flag)
set_pb_ready (& playback_api);
end_source = g_timeout_add (0, end_cb, NULL);
return NULL;
}
static void
import_winamp_file(const gchar * filename)
{
VFSFile * file = open_vfs_file (filename, "r");
if (! file)
return;
Index * list = aud_import_winamp_presets (file);
if (! list)
goto CLOSE;
index_copy_insert (list, 0, equalizer_presets, -1, -1);
index_free (list);
aud_equalizer_write_presets (equalizer_presets, "eq.preset");
CLOSE:
vfs_fclose(file);
}
static void
import_winamp_file(const gchar * filename)
{
VFSFile * file = open_vfs_file (filename, "r");
if (! file)
return;
Index * list = aud_import_winamp_eqf (file);
if (! list)
goto CLOSE;
index_merge_append (equalizer_presets, list);
index_free (list);
aud_equalizer_write_preset_file(equalizer_presets, "eq.preset");
CLOSE:
vfs_fclose(file);
}
bool_t playlist_load (const char * filename, char * * title,
Index * * filenames_p, Index * * tuples_p)
{
AUDDBG ("Loading playlist %s.\n", filename);
PluginHandle * plugin = get_plugin (filename, FALSE);
if (! plugin)
return FALSE;
PlaylistPlugin * pp = plugin_get_header (plugin);
g_return_val_if_fail (pp && PLUGIN_HAS_FUNC (pp, load), FALSE);
VFSFile * file = vfs_fopen (filename, "r");
if (! file)
return FALSE;
Index * filenames = index_new ();
Index * tuples = index_new ();
bool_t success = pp->load (filename, file, title, filenames, tuples);
vfs_fclose (file);
if (! success)
{
index_free (filenames);
index_free (tuples);
return FALSE;
}
if (index_count (tuples))
g_return_val_if_fail (index_count (tuples) == index_count (filenames),
FALSE);
else
{
index_free (tuples);
tuples = NULL;
}
* filenames_p = filenames;
* tuples_p = tuples;
return TRUE;
}
void RandomAccessFile_close (JNIEnv *env, w_instance thisRAF) {
w_instance fd_obj;
vfs_FILE *file;
fd_obj = getReferenceField(thisRAF, F_RandomAccessFile_fd);
if(fd_obj == NULL) {
throwNullPointerException(JNIEnv2w_thread(env));
} else {
file = getWotsitField(fd_obj, F_FileDescriptor_fd);
if(file) {
vfs_fclose(file);
clearWotsitField(fd_obj, F_FileDescriptor_fd);
}
}
}
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 gint probe_buffer_fclose (VFSFile * file)
{
gint ret = vfs_fclose (((ProbeBuffer *) file->handle)->file);
g_free (file->handle);
return ret;
}
static int xs_get_sid_hash(const char *filename, xs_md5hash_t hash)
{
VFSFile *inFile;
xs_md5state_t inState;
psidv1_header_t psidH;
psidv2_header_t psidH2;
uint8_t *songData;
uint8_t ib8[2], i8;
int index, result;
/* Try to open the file */
if ((inFile = vfs_fopen(filename, "rb")) == NULL)
return -1;
/* Read PSID header in */
if (vfs_fread(psidH.magicID, 1, sizeof psidH.magicID, inFile) < sizeof psidH.magicID) {
vfs_fclose(inFile);
return -1;
}
if (strncmp(psidH.magicID, "PSID", 4) && strncmp(psidH.magicID, "RSID", 4)) {
vfs_fclose(inFile);
xs_error("Not a PSID or RSID file '%s'\n", filename);
return -2;
}
psidH.version = xs_fread_be16(inFile);
psidH.dataOffset = xs_fread_be16(inFile);
psidH.loadAddress = xs_fread_be16(inFile);
psidH.initAddress = xs_fread_be16(inFile);
psidH.playAddress = xs_fread_be16(inFile);
psidH.nSongs = xs_fread_be16(inFile);
psidH.startSong = xs_fread_be16(inFile);
psidH.speed = xs_fread_be32(inFile);
if (vfs_fread(psidH.sidName, 1, sizeof psidH.sidName, inFile) < sizeof psidH.sidName
|| vfs_fread(psidH.sidAuthor, 1, sizeof psidH.sidAuthor, inFile) < sizeof psidH.sidAuthor
|| vfs_fread(psidH.sidCopyright, 1, sizeof psidH.sidCopyright, inFile) < sizeof psidH.sidCopyright) {
vfs_fclose(inFile);
xs_error("Error reading SID file header from '%s'\n", filename);
return -4;
}
/* Check if we need to load PSIDv2NG header ... */
psidH2.flags = 0; /* Just silence a stupid gcc warning */
if (psidH.version == 2) {
/* Yes, we need to */
psidH2.flags = xs_fread_be16(inFile);
psidH2.startPage = vfs_getc(inFile);
psidH2.pageLength = vfs_getc(inFile);
psidH2.reserved = xs_fread_be16(inFile);
}
/* Allocate buffer */
songData = (uint8_t *) malloc(XS_SIDBUF_SIZE * sizeof(uint8_t));
if (!songData) {
vfs_fclose(inFile);
xs_error("Error allocating temp data buffer for file '%s'\n", filename);
return -3;
}
/* Read data to buffer */
result = vfs_fread(songData, sizeof(uint8_t), XS_SIDBUF_SIZE, inFile);
vfs_fclose(inFile);
/* Initialize and start MD5-hash calculation */
xs_md5_init(&inState);
if (psidH.loadAddress == 0) {
/* Strip load address (2 first bytes) */
xs_md5_append(&inState, &songData[2], result - 2);
} else {
/* Append "as is" */
xs_md5_append(&inState, songData, result);
}
/* Free buffer */
free(songData);
/* Append header data to hash */
#define XSADDHASH(QDATAB) do { \
ib8[0] = (QDATAB & 0xff); \
ib8[1] = (QDATAB >> 8); \
xs_md5_append(&inState, (uint8_t *) &ib8, sizeof(ib8)); \
} while (0)
XSADDHASH(psidH.initAddress);
XSADDHASH(psidH.playAddress);
XSADDHASH(psidH.nSongs);
#undef XSADDHASH
/* Append song speed data to hash */
i8 = 0;
for (index = 0; (index < psidH.nSongs) && (index < 32); index++) {
i8 = (psidH.speed & (1 << index)) ? 60 : 0;
xs_md5_append(&inState, &i8, sizeof(i8));
}
/* Rest of songs (more than 32) */
for (index = 32; index < psidH.nSongs; index++) {
xs_md5_append(&inState, &i8, sizeof(i8));
}
/* PSIDv2NG specific */
if (psidH.version == 2) {
/* SEE SIDPLAY HEADERS FOR INFO */
i8 = (psidH2.flags >> 2) & 3;
if (i8 == 2)
xs_md5_append(&inState, &i8, sizeof(i8));
}
static void wv_deattach (VFSFile * wvc_input, WavpackContext * ctx)
{
if (wvc_input != NULL)
vfs_fclose(wvc_input);
WavpackCloseFile(ctx);
}
static void close_vfs(VFSSTREAMFILE *streamfile)
{
debugMessage("close_vfs");
vfs_fclose(streamfile->vfsFile);
free(streamfile);
}
