JNIEXPORT void JNICALL Java_com_ssb_droidsound_plugins_GMEPlugin_N_1unload(JNIEnv *env, jobject obj, jlong song)
{
GMEInfo *info = (GMEInfo*)song;
if(info->emu)
gme_delete(info->emu);
delete info;
}
// Callback hook to read streaming GME data.
static FMOD_RESULT F_CALLBACK GMEReadCallback(FMOD_SOUND *sound, void *data, unsigned int datalen)
{
Music_Emu *emu;
void *emuvoid = NULL;
// get our emu
FMR(FMOD_Sound_GetUserData(sound, &emuvoid));
emu = emuvoid;
// no emu? no play.
if (!emu)
return FMOD_ERR_FILE_EOF;
if (gme_track_ended(emu))
{
// don't delete the primary music stream
if (emu == gme)
return FMOD_ERR_FILE_EOF;
// do delete sfx streams
FMR(FMOD_Sound_SetUserData(sound, NULL));
gme_delete(emu);
return FMOD_ERR_FILE_EOF;
}
// play beautiful musics theme of ancient land.
if (gme_play(emu, datalen/2, data))
return FMOD_ERR_FILE_BAD;
// O.K
return FMOD_OK;
}
GmeDecoder::GmeDecoder(Data *data, const std::string &ext, int bufferSize)
: Decoder(data, ext, bufferSize)
, emu(0)
, num_tracks(0)
, cur_track(0)
{
void *d = data->getData();
int s = data->getSize();
if (gme_open_data(d, s, &emu, sampleRate) != 0)
throw love::Exception("Could not open game music file");
num_tracks = gme_track_count(emu);
try
{
if (num_tracks <= 0)
throw love::Exception("Game music file has no tracks");
if (gme_start_track(emu, cur_track) != 0)
throw love::Exception("Could not start game music playback");
}
catch (love::Exception &)
{
gme_delete(emu);
throw;
}
}
static GstStateChangeReturn
gst_gme_dec_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn result;
GstGmeDec *dec;
dec = GST_GME_DEC (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
dec->total_duration = GST_CLOCK_TIME_NONE;
break;
default:
break;
}
result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (result == GST_STATE_CHANGE_FAILURE)
return result;
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
gst_adapter_clear (dec->adapter);
if (dec->player) {
gme_delete (dec->player);
dec->player = NULL;
}
break;
default:
break;
}
return result;
}
static int read_close_gme(AVFormatContext *s)
{
GMEContext *gme = s->priv_data;
gme_free_info(gme->info);
gme_delete(gme->music_emu);
return 0;
}
/* Close the given Game Music Emulators stream */
void GME_delete(struct MUSIC_GME *music)
{
if(music)
{
if( music->mus_title )
{
SDL_free(music->mus_title);
}
if( music->mus_artist)
{
SDL_free(music->mus_artist);
}
if( music->mus_album)
{
SDL_free(music->mus_album);
}
if( music->mus_copyright)
{
SDL_free(music->mus_copyright);
}
if (music->game_emu)
{
gme_delete( music->game_emu );
music->game_emu=NULL;
}
music->playing=-1;
free(music);
}
}
void Java_de_illogical_modo_GmeDecoder_gmeReset(JNIEnv* env, jclass clazz)
{
if (emu != NULL)
gme_delete(emu);
emu = NULL;
}
MusInfo *GME_OpenSong(FILE *file, BYTE *musiccache, int len, const char *fmt)
{
gme_type_t type;
gme_err_t err;
BYTE *song;
Music_Emu *emu;
int sample_rate;
type = gme_identify_extension(fmt);
if (type == NULL)
{
return NULL;
}
sample_rate = (int)GSnd->GetOutputRate();
emu = gme_new_emu(type, sample_rate);
if (emu == NULL)
{
return NULL;
}
if (musiccache != NULL)
{
song = musiccache;
}
else
{
song = new BYTE[len];
if (fread(song, 1, len, file) != (size_t)len)
{
delete[] song;
gme_delete(emu);
return NULL;
}
}
err = gme_load_data(emu, song, len);
if (song != musiccache)
{
delete[] song;
}
if (err != NULL)
{
Printf("Failed loading song: %s\n", err);
gme_delete(emu);
return NULL;
}
return new GMESong(emu, sample_rate);
}
static void
cgme_free (DB_fileinfo_t *_info) {
gme_fileinfo_t *info = (gme_fileinfo_t*)_info;
if (info->emu) {
gme_delete (info->emu);
}
free (info);
}
void I_ShutdownSound(void)
{
I_Assert(sound_started);
sound_started = false;
#ifdef HAVE_LIBGME
if (gme)
gme_delete(gme);
#endif
FMR(FMOD_System_Release(fsys));
}
static void Close (vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = demux->p_sys;
for (unsigned i = 0, n = sys->titlec; i < n; i++)
vlc_input_title_Delete (sys->titlev[i]);
free (sys->titlev);
gme_delete (sys->emu);
free (sys);
}
void I_StopDigSong(void)
{
if (music_stream)
FMR(FMOD_Sound_Release(music_stream));
music_stream = NULL;
#ifdef HAVE_LIBGME
if (gme)
gme_delete(gme);
gme = NULL;
#endif
current_track = -1;
}
JNIEXPORT void JNICALL Java_com_ssb_droidsound_plugins_GMEPlugin_N_1unload(JNIEnv *env, jobject obj, jlong song)
{
GMEInfo *info = (GMEInfo*)song;
if (info->currentSong) {
gme_free_info(info->lastTrack);
}
if(info->emu) {
gme_delete(info->emu);
}
delete info;
}
void crPlayerCleanup(void *context)
{
gmeContext *gme = (gmeContext*)context;
if (gme->dataBuffer)
free(gme->dataBuffer);
gme->dataBuffer = NULL;
if (gme->entries)
free(gme->entries);
gme->entries = NULL;
if (gme->emu)
gme_delete(gme->emu);
gme->emu = NULL;
}
static void
xmms_gme_destroy (xmms_xform_t *xform)
{
xmms_gme_data_t *data;
g_return_if_fail (xform);
data = (xmms_gme_data_t *)xmms_xform_private_data_get (xform);
g_return_if_fail (data);
if (data->emu)
gme_delete (data->emu);
g_free (data);
}
GMESong::~GMESong()
{
Stop();
if (m_Stream != NULL)
{
delete m_Stream;
m_Stream = NULL;
}
if (TrackInfo != NULL)
{
gme_free_info(TrackInfo);
}
if (Emu != NULL)
{
gme_delete(Emu);
}
}
/**
* NOT USED
*/
void
Java_com_example_subtle_SoundMachine_convertToWave( JNIEnv* env, jobject callingObject, jstring fromPath, jstring toPath )
{
/* Buffer Size */
int buf_size = 1024; /* can be any multiple of 2 */
/* Grab Paths */
const char *from_path = (*env)->GetStringUTFChars(env, fromPath, 0);
const char *to_path = (*env)->GetStringUTFChars(env, toPath, 0);
/* Open music file in new emulator */
Music_Emu* emu;
handle_error( gme_open_file( from_path, &emu, SAMPLE_RATE ) );
/* Get Track Info */
gme_info_t* track_info = NULL;
handle_error( gme_track_info( emu, &track_info, TRACK ) );
/* Start track */
handle_error( gme_start_track( emu, TRACK ) );
/* Begin writing to wave file */
wave_open( SAMPLE_RATE, to_path );
wave_enable_stereo();
/* Output to Wave */
while ( gme_tell( emu ) < track_info->play_length )
{
/* Sample buffer */
short buf [buf_size];
/* Fill sample buffer */
handle_error( gme_play( emu, buf_size, buf ) );
/* Write samples to wave file */
wave_write( buf, buf_size );
}
/* Cleanup */
gme_free_info( track_info );
(*env)->ReleaseStringUTFChars(env, fromPath, from_path);
(*env)->ReleaseStringUTFChars(env, toPath, to_path);
gme_delete( emu );
wave_close();
}
int main(int argc, char *argv[])
{
const char *filename = "test.nsf"; /* Default file to open */
if ( argc >= 2 )
filename = argv[1];
long sample_rate = 44100; /* number of samples per second */
/* index of track to play (0 = first) */
int track = argc >= 3 ? atoi(argv[2]) : 0;
/* Open music file in new emulator */
Music_Emu* emu;
handle_error( gme_open_file( filename, &emu, sample_rate ) );
/* Start track */
handle_error( gme_start_track( emu, track ) );
/* Begin writing to wave file */
wave_open( sample_rate, "out.wav" );
wave_enable_stereo();
/* Record 10 seconds of track */
while ( gme_tell( emu ) < 10 * 1000L )
{
/* Sample buffer */
#define buf_size 1024 /* can be any multiple of 2 */
short buf [buf_size];
/* Fill sample buffer */
handle_error( gme_play( emu, buf_size, buf ) );
/* Write samples to wave file */
wave_write( buf, buf_size );
}
/* Cleanup */
gme_delete( emu );
wave_close();
return 0;
}
static DB_playItem_t *
cgme_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) {
Music_Emu *emu;
trace ("gme_open_file %s\n", fname);
gme_err_t res = "gme uninitialized";
const char *ext = strrchr (fname, '.');
char *buffer;
int sz;
if (!read_gzfile (fname, &buffer, &sz)) {
res = gme_open_data (fname, buffer, sz, &emu, gme_info_only);
free (buffer);
}
if (res) {
DB_FILE *f = deadbeef->fopen (fname);
if (!f) {
return NULL;
}
int64_t sz = deadbeef->fgetlength (f);
if (sz <= 0) {
deadbeef->fclose (f);
return NULL;
}
char *buf = malloc (sz);
if (!buf) {
deadbeef->fclose (f);
return NULL;
}
int64_t rb = deadbeef->fread (buf, 1, sz, f);
deadbeef->fclose(f);
if (rb != sz) {
free (buf);
return NULL;
}
res = gme_open_data (fname, buf, sz, &emu, gme_info_only);
free (buf);
}
if (!res) {
int cnt = gme_track_count (emu);
trace ("track cnt %d\n", cnt);
for (int i = 0; i < cnt; i++) {
#ifdef GME_VERSION_055
gme_info_t *inf;
const char *ret = gme_track_info (emu, &inf, i);
#else
track_info_t _inf;
const char *ret = gme_track_info (emu, &inf, i);
track_info_t *inf = &_inf;
#endif
if (!ret) {
DB_playItem_t *it = deadbeef->pl_item_alloc_init (fname, plugin.plugin.id);
char str[1024];
if (inf->song[0]) {
snprintf (str, sizeof(str), "%d %s - %s", i, inf->game, inf->song);
}
else {
snprintf (str, sizeof(str), "%d %s - ?", i, inf->game);
}
trace ("track subtune %d %s, length=%d\n", i, str, inf->length);
deadbeef->pl_set_meta_int (it, ":TRACKNUM", i);
// add metadata
cgme_add_meta (it, "system", inf->system);
cgme_add_meta (it, "album", inf->game);
int tl = sizeof (inf->song);
int n;
for (n = 0; i < tl && inf->song[n] && inf->song[n] == ' '; n++);
if (n == tl || !inf->song[n]) {
deadbeef->pl_add_meta (it, "title", NULL);
}
else {
cgme_add_meta (it, "title", inf->song);
}
cgme_add_meta (it, "artist", inf->author);
cgme_add_meta (it, "copyright", inf->copyright);
cgme_add_meta (it, "comment", inf->comment);
cgme_add_meta (it, "dumper", inf->dumper);
char trk[10];
snprintf (trk, 10, "%d", i+1);
cgme_add_meta (it, "track", trk);
snprintf (str, sizeof(str), "%d", inf->length);
deadbeef->pl_add_meta (it, ":GME_LENGTH", str);
snprintf (str, sizeof(str), "%d", inf->intro_length);
deadbeef->pl_add_meta (it, ":GME_INTRO_LENGTH", str);
snprintf (str, sizeof(str), "%d", inf->loop_length);
deadbeef->pl_add_meta (it, ":GME_LOOP_LENGTH", str);
if (inf->length == -1 || inf->length == 0) {
float songlength;
if (inf->loop_length > 0 && conf_loopcount > 0) {
songlength = inf->intro_length / 1000.f;
if (songlength < 0) {
songlength = 0;
}
songlength += (inf->loop_length * conf_loopcount) / 1000.f;
}
else {
songlength = deadbeef->conf_get_float ("gme.songlength", 3) * 60.f;
}
deadbeef->plt_set_item_duration (plt, it, songlength);
}
else {
deadbeef->plt_set_item_duration (plt, it, (float)inf->length/1000.f);
}
const char *ext = fname + strlen (fname) - 1;
while (ext >= fname && *ext != '.') {
ext--;
}
if (*ext == '.') {
ext++;
for (int i = 0; plugin.exts[i]; i++) {
if (!strcasecmp (ext, plugin.exts[i])) {
deadbeef->pl_add_meta (it, ":FILETYPE", plugin.exts[i]);
break;
}
}
}
if (cnt > 1) {
deadbeef->pl_set_item_flags (it, deadbeef->pl_get_item_flags (it) | DDB_IS_SUBTRACK);
}
after = deadbeef->plt_insert_item (plt, after, it);
deadbeef->pl_item_unref (it);
}
else {
trace ("gme error: %s\n", ret);
}
}
if (emu) {
gme_delete (emu);
}
}
else {
trace ("gme_open_file/data failed with error %s\n", res);
}
return after;
}
static event_t *
fa_gme_playfile_internal(media_pipe_t *mp, void *fh,
char *errbuf, size_t errlen, int hold, int track)
{
media_queue_t *mq = &mp->mp_audio;
Music_Emu *emu;
gme_err_t err;
char *buf;
int lost_focus = 0;
size_t size, r;
int sample_rate = 48000;
media_buf_t *mb = NULL;
event_t *e;
size = fa_fsize(fh);
buf = malloc(size);
r = fa_read(fh, buf, size);
if(r != size) {
snprintf(errbuf, errlen, "Unable to read file");
free(buf);
return NULL;
}
err = gme_open_data(buf, size, &emu, sample_rate);
free(buf);
if(err != NULL) {
snprintf(errbuf, errlen, "Unable to load file -- %s", err);
return NULL;
}
gme_start_track(emu, track);
mp_set_playstatus_by_hold(mp, hold, NULL);
mp->mp_audio.mq_stream = 0;
mp_set_play_caps(mp, MP_PLAY_CAPS_PAUSE | MP_PLAY_CAPS_SEEK);
mp_become_primary(mp);
while(1) {
if(gme_track_ended(emu)) {
e = event_create_type(EVENT_EOF);
break;
}
if(mb == NULL) {
mb = media_buf_alloc();
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_size = sizeof(int16_t) * CHUNK_SIZE * mb->mb_channels;
mb->mb_data = malloc(mb->mb_size);
mb->mb_rate = sample_rate;
mb->mb_time = gme_tell(emu) * 1000;
gme_play(emu, CHUNK_SIZE * mb->mb_channels, mb->mb_data);
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_type(e, EVENT_SEEK)) {
event_ts_t *ets = (event_ts_t *)e;
gme_seek(emu, ets->pts / 1000);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SEEK_FAST_BACKWARD)) {
deltaseek(mp, &mb, emu, -60000);
} else if(event_is_action(e, ACTION_SEEK_BACKWARD)) {
deltaseek(mp, &mb, emu, -15000);
} else if(event_is_action(e, ACTION_SEEK_FAST_FORWARD)) {
deltaseek(mp, &mb, emu, 60000);
} else if(event_is_action(e, ACTION_SEEK_FORWARD)) {
deltaseek(mp, &mb, emu, 15000);
} else if(event_is_action(e, ACTION_PLAYPAUSE) ||
event_is_action(e, ACTION_PLAY) ||
event_is_action(e, ACTION_PAUSE)) {
hold = action_update_hold_by_event(hold, e);
mp_send_cmd_head(mp, mq, hold ? MB_CTRL_PAUSE : MB_CTRL_PLAY);
lost_focus = 0;
mp_set_playstatus_by_hold(mp, hold, NULL);
} else if(event_is_type(e, EVENT_MP_NO_LONGER_PRIMARY)) {
hold = 1;
lost_focus = 1;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_type(e, EVENT_MP_IS_PRIMARY)) {
if(lost_focus) {
hold = 0;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, hold, NULL);
}
} else if(event_is_type(e, EVENT_INTERNAL_PAUSE)) {
hold = 1;
lost_focus = 0;
mp_send_cmd_head(mp, mq, MB_CTRL_PAUSE);
mp_set_playstatus_by_hold(mp, hold, e->e_payload);
} else if(event_is_action(e, ACTION_PREV_TRACK) ||
event_is_action(e, ACTION_NEXT_TRACK) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
gme_delete(emu);
if(mb != NULL)
media_buf_free(mb);
if(hold) {
// If we were paused, release playback again.
mp_send_cmd(mp, mq, MB_CTRL_PLAY);
mp_set_playstatus_by_hold(mp, 0, NULL);
}
return e;
}
GmeDecoder::~GmeDecoder()
{
if (emu)
gme_delete(emu);
}
static gboolean
gme_setup (GstGmeDec * gme)
{
gme_info_t *info;
gme_err_t gme_err = NULL;
GstTagList *taglist;
guint64 total_duration;
guint64 fade_time;
GstBuffer *buffer;
GstSegment seg;
GstMapInfo map;
if (!gst_adapter_available (gme->adapter) || !gme_negotiate (gme)) {
return FALSE;
}
buffer =
gst_adapter_take_buffer (gme->adapter,
gst_adapter_available (gme->adapter));
gst_buffer_map (buffer, &map, GST_MAP_READ);
gme_err = gme_open_data (map.data, map.size, &gme->player, 32000);
gst_buffer_unmap (buffer, &map);
gst_buffer_unref (buffer);
if (gme_err || !gme->player) {
if (gme->player) {
gme_delete (gme->player);
gme->player = NULL;
}
GST_ELEMENT_ERROR (gme, STREAM, DEMUX, (NULL), ("%s", gme_err));
return FALSE;
}
gme_err = gme_track_info (gme->player, &info, 0);
taglist = gst_tag_list_new_empty ();
if (info->song && *info->song)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_TITLE,
info->song, NULL);
if (info->author && *info->author)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ARTIST,
info->author, NULL);
/* Prefer the name of the official soundtrack over the name of the game (since this is
* how track numbers are derived)
*/
if (info->game && *info->game)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ALBUM, info->game,
NULL);
if (info->comment && *info->comment)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_COMMENT,
info->comment, NULL);
if (info->dumper && *info->dumper)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_CONTACT,
info->dumper, NULL);
if (info->copyright && *info->copyright)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_COPYRIGHT,
info->copyright, NULL);
if (info->system && *info->system)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER,
info->system, NULL);
gme->total_duration = total_duration =
gst_util_uint64_scale_int (info->play_length + (info->loop_length >
0 ? 8000 : 0), GST_MSECOND, 1);
fade_time = info->loop_length > 0 ? info->play_length : 0;
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE,
GST_TAG_DURATION, total_duration, NULL);
gst_pad_push_event (gme->srcpad, gst_event_new_tag (taglist));
g_free (info);
#ifdef HAVE_LIBGME_ACCURACY
/* TODO: Is it worth it to make this optional? */
gme_enable_accuracy (gme->player, 1);
#endif
gme_start_track (gme->player, 0);
if (fade_time)
gme_set_fade (gme->player, fade_time);
gst_segment_init (&seg, GST_FORMAT_TIME);
gst_pad_push_event (gme->srcpad, gst_event_new_segment (&seg));
gst_pad_start_task (gme->srcpad, (GstTaskFunction) gst_gme_play, gme->srcpad,
NULL);
gme->initialized = TRUE;
gme->seeking = FALSE;
gme->seekpoint = 0;
return gme->initialized;
}
void
Java_com_example_subtle_SoundMachine_fillBuffer( JNIEnv* env, jobject callingObject, jstring filePath, jshortArray bufferArray, jint myID )
{
/* Grab File Path */
const char *file_path = (*env)->GetStringUTFChars(env, filePath, 0);
/* Get Class Information */
jclass thisClass = (*env)->GetObjectClass(env, callingObject);
/* Open music file in new emulator */
Music_Emu* emu;
handle_error( gme_open_file( file_path, &emu, SAMPLE_RATE ) );
/* Get Track Info */
gme_info_t* track_info = NULL;
handle_error( gme_track_info( emu, &track_info, TRACK ) );
/* Start track */
handle_error( gme_start_track( emu, TRACK ) );
/* Start Filling Buffer */
jshort current_state = 0;
jfieldID fid_playback_command = (*env)->GetFieldID(env, thisClass, "JNIPlaybackCommand", "I");
jfieldID fid_active_thread = (*env)->GetFieldID(env, thisClass, "activeThreadID", "I");
jfieldID fid_seek_to = (*env)->GetFieldID(env, thisClass, "seekTo", "I");
jmethodID mid_write = (*env)->GetMethodID(env, thisClass, "fillBufferCallback", "(I)V");
jsize buffer_size = (*env)->GetArrayLength( env, bufferArray );
jshort *buffer_pointer;
jint command;
jint currentPosition;
jint activeID;
jint seekTo;
while ( 1 )
{
/**
* Read Control Commands
*/
/* Get Control Command */
command = (*env)->GetIntField(env, callingObject, fid_playback_command);
/* Get Active Thread ID */
activeID = (*env)->GetIntField(env, callingObject, fid_active_thread);
/* Get Seek To */
seekTo = (*env)->GetIntField(env, callingObject, fid_seek_to);
/**
* Respond to Control Commands
*/
if ( activeID != myID || command == SIG_STOP ) { // stop or new track is now playing
/* Exit */
break;
} else if (seekTo != SEEK_STATUS_NOT_SEEKING) {
/* Seek */
handle_error( gme_seek ( emu, seekTo ) );
/* Report Seek */
(*env)->CallVoidMethod(env, callingObject, mid_write, SEEK_STATUS_FINISHED_SEEKING);
} else if ( command == SIG_PLAY ) {
/* If We Finish, Kill Thread */
if (gme_tell( emu ) >= track_info->play_length) {
/* Write Buffer */
(*env)->CallVoidMethod(env, callingObject, mid_write, track_info->play_length); // Finished Track
/* Exit */
break;
}
/* Get Java Buffer */
buffer_pointer = (*env)->GetShortArrayElements( env, bufferArray, NULL );
/* Fill sample buffer */
handle_error( gme_play( emu, buffer_size, buffer_pointer ) );
/* Release Java Buffer */
(*env)->ReleaseShortArrayElements( env, bufferArray, buffer_pointer, 0 );
/* Get Current Position */
currentPosition = gme_tell( emu );
/* Write Buffer */
(*env)->CallVoidMethod(env, callingObject, mid_write, currentPosition);
} else if ( command == SIG_PAUSE ) {
/* Get Current Position */
currentPosition = gme_tell( emu );
/* Write Buffer */
(*env)->CallVoidMethod(env, callingObject, mid_write, currentPosition);
/* Sleep */
sleep(.1);
}
}
/* Cleanup */
(*env)->ReleaseStringUTFChars(env, filePath, file_path);
gme_free_info( track_info );
gme_delete( emu );
}
static event_t *
fa_gme_playfile_internal(media_pipe_t *mp, const void *buf, size_t size,
char *errbuf, size_t errlen, int hold, int track,
const char *url)
{
media_queue_t *mq = &mp->mp_audio;
Music_Emu *emu;
gme_err_t err;
int sample_rate = 48000;
media_buf_t *mb = NULL;
event_t *e;
int registered_play = 0;
err = gme_open_data(buf, size, &emu, sample_rate);
if(err != NULL) {
snprintf(errbuf, errlen, "Unable to load file -- %s", err);
return NULL;
}
gme_start_track(emu, track);
mp->mp_audio.mq_stream = 0;
mp_configure(mp, MP_PLAY_CAPS_PAUSE | MP_PLAY_CAPS_SEEK,
MP_BUFFER_SHALLOW, 0);
mp_become_primary(mp);
while(1) {
if(gme_track_ended(emu)) {
e = event_create_type(EVENT_EOF);
break;
}
if(mb == NULL) {
mb = media_buf_alloc_unlocked(mp, sizeof(int16_t) * CHUNK_SIZE * 2);
mb->mb_data_type = MB_AUDIO;
mb->mb_channels = 2;
mb->mb_rate = sample_rate;
mb->mb_pts = gme_tell(emu) * 1000;
mb->mb_drive_clock = 1;
if(!registered_play && mb->mb_pts > METADB_AUDIO_PLAY_THRESHOLD) {
registered_play = 1;
metadb_register_play(url, 1, CONTENT_AUDIO);
}
gme_play(emu, CHUNK_SIZE * mb->mb_channels, mb->mb_data);
}
if((e = mb_enqueue_with_events(mp, mq, mb)) == NULL) {
mb = NULL; /* Enqueue succeeded */
continue;
}
if(event_is_type(e, EVENT_PLAYQUEUE_JUMP)) {
mp_flush(mp, 0);
break;
} else if(event_is_type(e, EVENT_SEEK)) {
event_ts_t *ets = (event_ts_t *)e;
gme_seek(emu, ets->ts / 1000);
seekflush(mp, &mb);
} else if(event_is_action(e, ACTION_SKIP_BACKWARD) ||
event_is_action(e, ACTION_SKIP_FORWARD) ||
event_is_action(e, ACTION_STOP)) {
mp_flush(mp, 0);
break;
}
event_release(e);
}
gme_delete(emu);
if(mb != NULL)
media_buf_free_unlocked(mp, mb);
return e;
}
MaxMusicEmu::~MaxMusicEmu()
{
if (emu) {
gme_delete(emu);
}
}
struct MUSIC_GME *GME_LoadSongRW(SDL_RWops *src, int trackNum)
{
if(src != NULL) {
void *bytes=0;
long spcsize;
Sint64 length=0;
length = SDL_RWseek(src, 0, RW_SEEK_END);
if (length < 0)
{
Mix_SetError("GAME-EMU: wrong file\n");
return NULL;
}
SDL_RWseek(src, 0, RW_SEEK_SET);
bytes = malloc(length);
long bytes_l;
unsigned char byte[1];
spcsize=0;
while( (bytes_l=SDL_RWread(src, &byte, sizeof(unsigned char), 1))!=0)
{
((unsigned char*)bytes)[spcsize] = byte[0];
spcsize++;
}
if (spcsize == 0)
{
Mix_SetError("GAME-EMU: wrong file\n");
return NULL;
}
Music_Emu* game_emu;
char *err = (char*)gme_open_data( bytes, spcsize, &game_emu, gme_t_sample_rate );
//spc_load_spc( snes_spc, bytes, spcsize );
free(bytes);
if(err!=0)
{
Mix_SetError("GAME-EMU: %s", err);
return NULL;
}
if((trackNum<0)||(trackNum >= gme_track_count(game_emu)))
trackNum = gme_track_count(game_emu)-1;
err = (char*)gme_start_track( game_emu, trackNum );
if(err!=0)
{
Mix_SetError("GAME-EMU: %s", err);
return NULL;
}
struct MUSIC_GME *spcSpec = (struct MUSIC_GME*)malloc(sizeof(struct MUSIC_GME));
spcSpec->game_emu=game_emu;
spcSpec->playing=0;
spcSpec->gme_t_sample_rate=mixer.freq;
spcSpec->volume=MIX_MAX_VOLUME;
spcSpec->mus_title=NULL;
spcSpec->mus_artist=NULL;
spcSpec->mus_album=NULL;
spcSpec->mus_copyright=NULL;
gme_info_t *musInfo;
err = (char*)gme_track_info(spcSpec->game_emu, &musInfo, trackNum);
if(err!=0)
{
gme_delete(spcSpec->game_emu);
free(spcSpec);
Mix_SetError("GAME-EMU: %s", err);
return NULL;
}
spcSpec->mus_title = (char *)SDL_malloc(sizeof(char)*strlen(musInfo->song)+1);
strcpy(spcSpec->mus_title, musInfo->song);
spcSpec->mus_artist = (char *)SDL_malloc(sizeof(char)*strlen(musInfo->author)+1);
strcpy(spcSpec->mus_artist, musInfo->author);
spcSpec->mus_album = (char *)SDL_malloc(sizeof(char)*strlen(musInfo->game)+1);
strcpy(spcSpec->mus_album, musInfo->game);
spcSpec->mus_copyright = (char *)SDL_malloc(sizeof(char)*strlen(musInfo->copyright)+1);
strcpy(spcSpec->mus_copyright, musInfo->copyright);
gme_free_info( musInfo );
SDL_BuildAudioCVT(&spcSpec->cvt, AUDIO_S16, 2,
mixer.freq,
mixer.format,
mixer.channels,
mixer.freq);
return spcSpec;
}
return NULL;
}
int crPlayerSetTrack(void *context, int track)
{
gmeContext *gme = (gmeContext*)context;
gme_err_t status = NULL;
int trueTrack;
fileEntry *entry;
/* initialize the engine */
if (gme->isGameMusicArchive)
{
/* when it's time to start a track, it's always going to be
* track 0 (first and only) of a single-song file */
trueTrack = 0;
/* if a file is already being played, free it first */
if (gme->emu)
{
gme_delete(gme->emu);
gme->emu = NULL;
}
entry = &gme->entries[track];
status = gme_open_data(gme->dataBuffer + entry->offset, entry->size,
&gme->emu, gme->sampleRate);
if (status)
return 0;
}
else
{
trueTrack = track;
/* if the player isn't already open, do the initialization */
if (!gme->emu)
{
status = gme_open_data(gme->dataBuffer, gme->dataBufferSize,
&gme->emu, gme->sampleRate);
if (status)
return 0;
}
}
/* set the track */
status = gme_start_track(gme->emu, trueTrack);
if (!status)
{
gme_type_t type = gme_type(gme->emu);
gme->voiceCount = gme_voice_count(gme->emu);
/* return either mono or stereo depending on the file type */
if ((type == gme_gbs_type) ||
(type == gme_spc_type) ||
(type == gme_vgm_type))
return 2; /* stereo */
else
return 1; /* mono */
}
else
{
gme_delete(gme->emu);
gme->emu = NULL;
return 0;
}
}
static int
gme_probe(metadata_t *md, const char *url, fa_handle_t *fh)
{
uint8_t b4[4], *buf;
gme_err_t err;
Music_Emu *emu;
gme_info_t *info;
int tracks;
size_t size;
const char *type;
if(fa_read(fh, b4, 4) != 4)
return 0;
type = gme_identify_header(b4);
if(*type == 0)
return 0;
size = fa_fsize(fh);
if(size == -1)
return -1;
buf = malloc(size);
fa_seek(fh, 0, SEEK_SET);
if(fa_read(fh, buf, size) != size) {
free(buf);
return 0;
}
err = gme_open_data(buf, size, &emu, gme_info_only);
free(buf);
if(err != NULL)
return 0;
err = gme_track_info(emu, &info, 0);
if(err != NULL) {
gme_delete(emu);
return 0;
}
tracks = gme_track_count(emu);
#if 0
printf("tracks : %d\n", tracks);
printf("system : %s\n", info->system);
printf("game : %s\n", info->game);
printf("song : %s\n", info->song);
printf("author : %s\n", info->author);
printf("copyright: %s\n", info->copyright);
printf("comment : %s\n", info->comment);
printf("dumper : %s\n", info->dumper);
#endif
if(tracks == 1) {
md->md_title = info->song[0] ? rstr_alloc(info->song) : NULL;
md->md_album = info->game[0] ? rstr_alloc(info->game) : NULL;
md->md_artist = info->author[0] ? rstr_alloc(info->author) : NULL;
md->md_duration = info->play_length / 1000.0;
md->md_contenttype = CONTENT_AUDIO;
} else {
md->md_title = info->game[0] ? rstr_alloc(info->game) : NULL;
md->md_artist = info->author[0] ? rstr_alloc(info->author) : NULL;
md->md_contenttype = CONTENT_ALBUM;
metdata_set_redirect(md, "gmefile://%s/", url);
}
gme_free_info(info);
gme_delete(emu);
return 1;
}
static int
gmefile_scandir(fa_dir_t *fd, const char *url, char *errbuf, size_t errlen)
{
char *p, *fpath = mystrdupa(url);
char name[32];
char turl[URL_MAX];
int tracks, i;
fa_dir_entry_t *fde;
const char *title;
Music_Emu *emu;
gme_info_t *info;
gme_err_t err;
if((p = strrchr(fpath, '/')) == NULL) {
snprintf(errbuf, errlen, "Invalid filename");
return -1;
}
*p = 0;
buf_t *b;
if((b = fa_load(fpath, NULL, errbuf, errlen, NULL,
0, NULL, NULL)) == NULL)
return -1;
err = gme_open_data(b->b_ptr, b->b_size, &emu, gme_info_only);
buf_release(b);
if(err != NULL)
return 0;
tracks = gme_track_count(emu);
for(i = 0; i < tracks; i++) {
snprintf(turl, sizeof(turl), "gmeplayer:%s/%d", fpath, i + 1);
err = gme_track_info(emu, &info, i);
if(err == NULL && info->song[0]) {
title = info->song;
} else {
snprintf(name, sizeof(name), "Track %02d", i + 1);
title = name;
}
fde = fa_dir_add(fd, turl, title, CONTENT_AUDIO);
fde->fde_probestatus = FDE_PROBE_DEEP;
fde->fde_metadata = prop_create_root("metadata");
prop_set_string(prop_create(fde->fde_metadata, "title"), title);
if(err == NULL) {
if(info->game[0])
prop_set_string(prop_create(fde->fde_metadata, "album"), info->game);
if(info->author[0])
prop_set_string(prop_create(fde->fde_metadata, "artist"), info->author);
prop_set_float(prop_create(fde->fde_metadata, "duration"),
info->play_length / 1000.0);
gme_free_info(info);
}
}
gme_delete(emu);
return 0;
}
void
Java_com_example_subtle_SNESTrack_loadTrackInfo( JNIEnv* env, jobject callingObject, jstring filePath )
{
/* Grab File Path */
const char *file_path = (*env)->GetStringUTFChars(env, filePath, 0);
/* Load Emulator */
Music_Emu* emu;
handle_error( gme_open_file( file_path, &emu, SAMPLE_RATE ) );
/* Get Track Info */
gme_info_t* track_info = NULL;
handle_error( gme_track_info( emu, &track_info, TRACK ) );
/* Get Class Information */
jclass thisClass = (*env)->GetObjectClass(env, callingObject);
/* Return Track Play Length */
jfieldID fid_track_play_length = (*env)->GetFieldID(env, thisClass, "playLength", "I");
(*env)->SetIntField(env, callingObject, fid_track_play_length, track_info->play_length);
/* Return Track Length */
jfieldID fid_track_length = (*env)->GetFieldID(env, thisClass, "length", "I");
(*env)->SetIntField(env, callingObject, fid_track_length, track_info->length);
/* Return Track Name */
jfieldID fid_track_name = (*env)->GetFieldID(env, thisClass, "trackName", "Ljava/lang/String;");
jstring track_name = (*env)->NewStringUTF(env, track_info->song);
(*env)->SetObjectField(env, callingObject, fid_track_name, track_name);
/* Return Game Name */
jfieldID fid_game_name = (*env)->GetFieldID(env, thisClass, "gameName", "Ljava/lang/String;");
jstring game_name = (*env)->NewStringUTF(env, track_info->game);
(*env)->SetObjectField(env, callingObject, fid_game_name, game_name);
/* Return System Name */
jfieldID fid_system_name = (*env)->GetFieldID(env, thisClass, "systemName", "Ljava/lang/String;");
jstring system_name = (*env)->NewStringUTF(env, track_info->system);
(*env)->SetObjectField(env, callingObject, fid_system_name, system_name);
/* Return Author Name */
jfieldID fid_author_name = (*env)->GetFieldID(env, thisClass, "authorName", "Ljava/lang/String;");
jstring author_name = (*env)->NewStringUTF(env, track_info->author);
(*env)->SetObjectField(env, callingObject, fid_author_name, author_name);
/* Return Copyright */
jfieldID fid_copyright = (*env)->GetFieldID(env, thisClass, "copyright", "Ljava/lang/String;");
jstring copyright = (*env)->NewStringUTF(env, track_info->copyright);
(*env)->SetObjectField(env, callingObject, fid_copyright, copyright);
/* Return Comment */
jfieldID fid_comment = (*env)->GetFieldID(env, thisClass, "comment", "Ljava/lang/String;");
jstring comment = (*env)->NewStringUTF(env, track_info->comment);
(*env)->SetObjectField(env, callingObject, fid_comment, comment);
/* Return Dumper */
jfieldID fid_dumper = (*env)->GetFieldID(env, thisClass, "dumper", "Ljava/lang/String;");
jstring dumper = (*env)->NewStringUTF(env, track_info->dumper);
(*env)->SetObjectField(env, callingObject, fid_dumper, dumper);
/* Cleanup */
(*env)->ReleaseStringUTFChars(env, filePath, file_path);
gme_free_info( track_info );
gme_delete( emu );
}
