Tuple *psf2_tuple(const char *filename, VFSFile *file)
{
Tuple *t;
corlett_t *c;
void *buf;
int64_t sz;
vfs_file_get_contents (filename, & buf, & sz);
if (!buf)
return NULL;
if (corlett_decode(buf, sz, NULL, NULL, &c) != AO_SUCCESS)
return NULL;
t = tuple_new_from_filename(filename);
tuple_set_int(t, FIELD_LENGTH, NULL, c->inf_length ? psfTimeToMS(c->inf_length) + psfTimeToMS(c->inf_fade) : -1);
tuple_set_str(t, FIELD_ARTIST, NULL, c->inf_artist);
tuple_set_str(t, FIELD_ALBUM, NULL, c->inf_game);
tuple_set_str(t, -1, "game", c->inf_game);
tuple_set_str(t, FIELD_TITLE, NULL, c->inf_title);
tuple_set_str(t, FIELD_COPYRIGHT, NULL, c->inf_copy);
tuple_set_str(t, FIELD_QUALITY, NULL, _("sequenced"));
tuple_set_str(t, FIELD_CODEC, NULL, "PlayStation 1/2 Audio");
tuple_set_str(t, -1, "console", "PlayStation 1/2");
free(c);
free(buf);
return t;
}
/* ao_get_lib: called to load secondary files */
int ao_get_lib(char *filename, uint8_t **buffer, uint64_t *length)
{
void *filebuf;
int64_t size;
SPRINTF(path2, "%s/%s", dirpath, filename);
vfs_file_get_contents(path2, &filebuf, &size);
*buffer = filebuf;
*length = (uint64_t)size;
return AO_SUCCESS;
}
static bool_t psf2_play(const char * filename, VFSFile * file)
{
void *buffer;
int64_t size;
PSFEngine eng;
bool_t error = FALSE;
const char * slash = strrchr (filename, '/');
if (! slash)
return FALSE;
SNCOPY (dirbuf, filename, slash + 1 - filename);
dirpath = dirbuf;
vfs_file_get_contents (filename, & buffer, & size);
eng = psf_probe(buffer);
if (eng == ENG_NONE || eng == ENG_COUNT)
{
free(buffer);
return FALSE;
}
f = &psf_functor_map[eng];
if (f->start(buffer, size) != AO_SUCCESS)
{
free(buffer);
return FALSE;
}
aud_input_open_audio(FMT_S16_NE, 44100, 2);
aud_input_set_bitrate(44100*2*2*8);
stop_flag = FALSE;
f->execute();
f->stop();
f = NULL;
dirpath = NULL;
free(buffer);
return ! error;
}
static bool_t psf2_play(InputPlayback * data, const char * filename, VFSFile * file, int start_time, int stop_time, bool_t pause)
{
void *buffer;
int64_t size;
PSFEngine eng;
PSFEngineFunctors *f;
bool_t error = FALSE;
path = strdup(filename);
vfs_file_get_contents (filename, & buffer, & size);
eng = psf_probe(buffer);
if (eng == ENG_NONE || eng == ENG_COUNT)
{
free(buffer);
return FALSE;
}
f = &psf_functor_map[eng];
if (f->start(buffer, size) != AO_SUCCESS)
{
free(buffer);
return FALSE;
}
data->output->open_audio(FMT_S16_NE, 44100, 2);
data->set_params(data, 44100*2*2*8, 44100, 2);
stop_flag = FALSE;
data->set_pb_ready(data);
for (;;)
{
f->execute(data);
if (seek)
{
data->output->flush(seek);
f->stop();
if (f->start(buffer, size) == AO_SUCCESS)
{
f->seek(seek);
seek = 0;
continue;
}
else
break;
}
f->stop();
break;
}
pthread_mutex_lock (& mutex);
stop_flag = TRUE;
pthread_mutex_unlock (& mutex);
free(buffer);
free(path);
return ! error;
}
INIFile *open_ini_file(const gchar *filename)
{
GHashTable *ini_file = NULL;
GHashTable *section = NULL;
GString *section_name, *key_name, *value;
gpointer section_hash, key_hash;
guchar * buffer = NULL;
gsize off = 0;
gint64 filesize = 0;
unsigned char x[] = { 0xff, 0xfe, 0x00 };
g_return_val_if_fail(filename, NULL);
void * vbuf = NULL;
vfs_file_get_contents (filename, & vbuf, & filesize);
if (! vbuf)
return NULL;
buffer = vbuf;
/*
* Convert UTF-16 into something useful. Original implementation
* by incomp@#audacious. Cleanups \nenolod
* FIXME: can't we use a GLib function for that? -- 01mf02
*/
if (filesize > 2 && !memcmp(&buffer[0], &x, 2))
{
guchar *outbuf = g_malloc (filesize); /* it's safe to waste memory. */
guint counter;
for (counter = 2; counter < filesize; counter += 2)
{
if (!memcmp(&buffer[counter + 1], &x[2], 1))
{
outbuf[(counter - 2) / 2] = buffer[counter];
}
else
{
g_free(buffer);
g_free(outbuf);
return NULL;
}
}
outbuf[(counter - 2) / 2] = '\0';
if ((filesize - 2) / 2 == (counter - 2) / 2)
{
g_free(buffer);
buffer = outbuf;
}
else
{
g_free(buffer);
g_free(outbuf);
return NULL; /* XXX wrong encoding */
}
}
section_name = g_string_new("");
key_name = g_string_new(NULL);
value = g_string_new(NULL);
ini_file =
g_hash_table_new_full(NULL, NULL, NULL, close_ini_file_free_section);
section =
g_hash_table_new_full(NULL, NULL, NULL, close_ini_file_free_value);
/* make a nameless section which should store all entries that are not
* embedded in a section */
section_hash = GINT_TO_POINTER(g_string_hash(section_name));
g_hash_table_insert(ini_file, section_hash, section);
while (off < filesize)
{
/* ignore the following characters */
if (buffer[off] == '\r' || buffer[off] == '\n' || buffer[off] == ' '
|| buffer[off] == '\t')
{
if (buffer[off] == '\n')
{
g_string_free(key_name, TRUE);
g_string_free(value, TRUE);
key_name = g_string_new(NULL);
value = g_string_new(NULL);
}
off++;
continue;
}
/* if we encounter a possible section statement */
if (buffer[off] == '[')
{
g_string_free(section_name, TRUE);
section_name = g_string_new(NULL);
off++;
if (off >= filesize)
goto return_sequence;
while (buffer[off] != ']')
{
/* if the section statement has not been closed before a
* linebreak */
if (buffer[off] == '\n')
break;
g_string_append_c(section_name, buffer[off]);
off++;
if (off >= filesize)
goto return_sequence;
}
if (buffer[off] == '\n')
continue;
if (buffer[off] == ']')
{
off++;
if (off >= filesize)
goto return_sequence;
strip_lower_string(section_name);
section_hash = GINT_TO_POINTER(g_string_hash(section_name));
/* if this section already exists, we don't make a new one,
* but reuse the old one */
if (g_hash_table_lookup(ini_file, section_hash) != NULL)
section = g_hash_table_lookup(ini_file, section_hash);
else
{
section =
g_hash_table_new_full(NULL, NULL, NULL,
close_ini_file_free_value);
g_hash_table_insert(ini_file, section_hash, section);
}
continue;
}
}
if (buffer[off] == '=')
{
off++;
if (off >= filesize)
goto return_sequence;
while (buffer[off] != '\n' && buffer[off] != '\r')
{
g_string_append_c(value, buffer[off]);
off++;
if (off >= filesize)
break;
}
strip_lower_string(key_name);
key_hash = GINT_TO_POINTER(g_string_hash(key_name));
strip_string(value);
if (key_name->len > 0 && value->len > 0)
g_hash_table_insert(section, key_hash, g_strdup(value->str));
}
else
{
g_string_append_c(key_name, buffer[off]);
off++;
if (off >= filesize)
goto return_sequence;
}
}
return_sequence:
g_string_free(section_name, TRUE);
g_string_free(key_name, TRUE);
g_string_free(value, TRUE);
g_free(buffer);
return ini_file;
}
