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