jlong Java_de_illogical_modo_SpcDecoder_spcTrackLength(JNIEnv* env, jclass clazz, jint track)
{
gme_err_t err = NULL;
struct gme_info_t* trackinfo;
int l = -1;
if (emu == NULL)
{
return -1;
}
err = gme_track_info(emu, &trackinfo, track);
if (err == NULL)
{
l = trackinfo->length;
gme_free_info(trackinfo);
return l;
}
return -1;
}
void Java_de_illogical_modo_SpcDecoder_spcGetTrackInfo(JNIEnv* env, jclass clazz, jint track, jint what, jbyteArray s) {
struct gme_info_t* trackinfo;
int size = (*env)->GetArrayLength(env, s);
if (emu == NULL)
return;
if (size > 255)
return;
gme_err_t err = gme_track_info(emu, &trackinfo, track);
if (err == NULL)
{
switch (what)
{
case 0: (*env)->SetByteArrayRegion(env, s, 0, size, trackinfo->system); break;
case 1: (*env)->SetByteArrayRegion(env, s, 0, size, trackinfo->game); break;
case 2: (*env)->SetByteArrayRegion(env, s, 0, size, trackinfo->song); break;
case 3: (*env)->SetByteArrayRegion(env, s, 0, size, trackinfo->author); break;
case 4: (*env)->SetByteArrayRegion(env, s, 0, size, trackinfo->copyright); break;
case 5: (*env)->SetByteArrayRegion(env, s, 0, size, trackinfo->comment); break;
case 6: (*env)->SetByteArrayRegion(env, s, 0, size, trackinfo->dumper); break;
}
}
gme_free_info(trackinfo);
}
jint Java_de_illogical_modo_GmeDecoder_gmeGetTrackInfoLength(JNIEnv* env, jclass clazz, jint track, jint what) {
struct gme_info_t* trackinfo;
int size = 0;
if (emu == NULL)
return;
gme_err_t err = gme_track_info(emu, &trackinfo, track);
if (err == NULL)
{
switch (what)
{
case 0:
size = strnlen(trackinfo->system, 255);
break;
case 1:
size = strnlen(trackinfo->game, 255);
break;
case 2:
size = strnlen(trackinfo->song, 255);
break;
case 3:
size = strnlen(trackinfo->author, 255);
break;
case 4:
size = strnlen(trackinfo->copyright, 255);
break;
case 5:
size = strnlen(trackinfo->comment, 255);
break;
case 6:
size = strnlen(trackinfo->dumper, 255);
break;
}
}
gme_free_info(trackinfo);
return size;
}
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;
}
jlong setUp(Music_Emu *emu)
{
gme_err_t err;
track_info_t track0, track1;
track0.song[0] = 0;
track1.song[0] = 0;
err = gme_track_info(emu, &track0, 0);
int track_count = gme_track_count(emu);
//info->gme_track_count();
__android_log_print(ANDROID_LOG_VERBOSE, "GMEPlugin", "(RC %s) -> SONG '%s' GAME '%s' LEN '%d' COUNT '%d'", err, track0.song, track0.game, track0.length, track_count);
char *xptr = &track0.song[strlen(track0.song)-1];
while(xptr >= track0.song && *xptr == 0x20) {
*xptr = 0;
xptr--;
}
if(!err) {
GMEInfo *info = new GMEInfo();
if(!strlen(track0.song)) {
bool nameOk = false;
// If name is all upper case it is most likely a rom name
for(int i=0; i<strlen(track0.game); i++) {
char c = track0.game[i];
if(isalpha(c) && !isupper(c)) {
nameOk = true;
}
}
if(nameOk) {
strcpy(info->mainTitle, track0.game);
} else {
info->mainTitle[0] = 0;
}
} else {
strcpy(info->mainTitle, track0.song);
if(track_count > 1) {
err = gme_track_info(emu, &track1, 1);
__android_log_print(ANDROID_LOG_VERBOSE, "GMEPlugin", "'%s' vs '%s'", track0.song, track1.song);
if(!err && strcmp(track0.song, track1.song) != 0) {
// We have more than one subsong, and their names differ
strcpy(info->mainTitle, track0.game);
}
}
}
info->started = false;
info->emu = emu;
info->currentSong = 0;
info->lastTrack = track0;
info->trackCount = track_count;
return (jlong)info;
}
return 0;
}
void *I_GetSfx(sfxinfo_t *sfx)
{
FMOD_SOUND *sound;
char *lump;
FMOD_CREATESOUNDEXINFO fmt;
#ifdef HAVE_LIBGME
Music_Emu *emu;
gme_info_t *info;
#endif
if (sfx->lumpnum == LUMPERROR)
sfx->lumpnum = S_GetSfxLumpNum(sfx);
sfx->length = W_LumpLength(sfx->lumpnum);
lump = W_CacheLumpNum(sfx->lumpnum, PU_SOUND);
sound = ds2fmod(lump);
if (sound)
{
Z_Free(lump);
return sound;
}
// It's not a doom sound.
// Try to read it as an FMOD sound?
memset(&fmt, 0, sizeof(FMOD_CREATESOUNDEXINFO));
fmt.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
fmt.length = sfx->length;
#ifdef HAVE_LIBGME
// VGZ format
if ((UINT8)lump[0] == 0x1F
&& (UINT8)lump[1] == 0x8B)
{
#ifdef HAVE_ZLIB
UINT8 *inflatedData;
size_t inflatedLen;
z_stream stream;
int zErr; // Somewhere to handle any error messages zlib tosses out
memset(&stream, 0x00, sizeof (z_stream)); // Init zlib stream
// Begin the inflation process
inflatedLen = *(UINT32 *)(lump + (sfx->length-4)); // Last 4 bytes are the decompressed size, typically
inflatedData = (UINT8 *)Z_Malloc(inflatedLen, PU_SOUND, NULL); // Make room for the decompressed data
stream.total_in = stream.avail_in = sfx->length;
stream.total_out = stream.avail_out = inflatedLen;
stream.next_in = (UINT8 *)lump;
stream.next_out = inflatedData;
zErr = inflateInit2(&stream, 32 + MAX_WBITS);
if (zErr == Z_OK) // We're good to go
{
zErr = inflate(&stream, Z_FINISH);
if (zErr == Z_STREAM_END) {
// Run GME on new data
if (!gme_open_data(inflatedData, inflatedLen, &emu, 44100))
{
Z_Free(inflatedData); // GME supposedly makes a copy for itself, so we don't need this lying around
Z_Free(lump); // We're done with the uninflated lump now, too.
gme_start_track(emu, 0);
gme_track_info(emu, &info, 0);
fmt.format = FMOD_SOUND_FORMAT_PCM16;
fmt.defaultfrequency = 44100;
fmt.numchannels = 2;
fmt.length = ((UINT32)info->play_length * 441 / 10) * 4;
fmt.decodebuffersize = (44100 * 2) / 35;
fmt.pcmreadcallback = GMEReadCallback;
fmt.userdata = emu;
FMR(FMOD_System_CreateSound(fsys, NULL, FMOD_CREATESAMPLE|FMOD_OPENUSER|FMOD_SOFTWARE|FMOD_LOWMEM, &fmt, &sound));
return sound;
}
}
else
{
const char *errorType;
switch (zErr)
{
case Z_ERRNO:
errorType = "Z_ERRNO"; break;
case Z_STREAM_ERROR:
errorType = "Z_STREAM_ERROR"; break;
case Z_DATA_ERROR:
errorType = "Z_DATA_ERROR"; break;
case Z_MEM_ERROR:
errorType = "Z_MEM_ERROR"; break;
case Z_BUF_ERROR:
errorType = "Z_BUF_ERROR"; break;
case Z_VERSION_ERROR:
errorType = "Z_VERSION_ERROR"; break;
default:
errorType = "unknown error";
}
CONS_Alert(CONS_ERROR,"Encountered %s when running inflate: %s\n", errorType, stream.msg);
}
(void)inflateEnd(&stream);
}
else // Hold up, zlib's got a problem
{
const char *errorType;
switch (zErr)
{
case Z_ERRNO:
errorType = "Z_ERRNO"; break;
case Z_STREAM_ERROR:
errorType = "Z_STREAM_ERROR"; break;
case Z_DATA_ERROR:
errorType = "Z_DATA_ERROR"; break;
case Z_MEM_ERROR:
errorType = "Z_MEM_ERROR"; break;
case Z_BUF_ERROR:
errorType = "Z_BUF_ERROR"; break;
case Z_VERSION_ERROR:
errorType = "Z_VERSION_ERROR"; break;
default:
errorType = "unknown error";
}
CONS_Alert(CONS_ERROR,"Encountered %s when running inflateInit: %s\n", errorType, stream.msg);
}
Z_Free(inflatedData); // GME didn't open jack, but don't let that stop us from freeing this up
#else
//CONS_Alert(CONS_ERROR,"Cannot decompress VGZ; no zlib support\n");
#endif
}
// Try to read it as a GME sound
else if (!gme_open_data(lump, sfx->length, &emu, 44100))
{
Z_Free(lump);
gme_start_track(emu, 0);
gme_track_info(emu, &info, 0);
fmt.format = FMOD_SOUND_FORMAT_PCM16;
fmt.defaultfrequency = 44100;
fmt.numchannels = 2;
fmt.length = ((UINT32)info->play_length * 441 / 10) * 4;
fmt.decodebuffersize = (44100 * 2) / 35;
fmt.pcmreadcallback = GMEReadCallback;
fmt.userdata = emu;
gme_free_info(info);
FMR(FMOD_System_CreateSound(fsys, NULL, FMOD_CREATESAMPLE|FMOD_OPENUSER|FMOD_SOFTWARE|FMOD_LOWMEM, &fmt, &sound));
return sound;
}
#endif
// Ogg, Mod, Midi, etc.
FMR(FMOD_System_CreateSound(fsys, lump, FMOD_CREATESAMPLE|FMOD_OPENMEMORY|FMOD_SOFTWARE|FMOD_LOWMEM, &fmt, &sound));
Z_Free(lump); // We're done with the lump now, at least.
return sound;
}
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;
}
static int Open (vlc_object_t *obj)
{
demux_t *demux = (demux_t *)obj;
int64_t size = stream_Size (demux->s);
if (size > LONG_MAX /* too big for GME */)
return VLC_EGENERIC;
/* Auto detection */
const uint8_t *peek;
if (stream_Peek (demux->s, &peek, 4) < 4)
return VLC_EGENERIC;
const char *type = gme_identify_header (peek);
if (!*type)
return VLC_EGENERIC;
msg_Dbg (obj, "detected file type %s", type);
block_t *data = NULL;
if (size <= 0)
{
data = stream_Block (demux->s, 1 << 24);
if (data == NULL)
return VLC_EGENERIC;
}
/* Initialization */
demux_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
sys->emu = gme_new_emu (gme_identify_extension (type), RATE);
if (sys->emu == NULL)
{
free (sys);
return VLC_ENOMEM;
}
if (data)
{
gme_load_custom (sys->emu, ReaderBlock, data->i_buffer, data);
block_Release(data);
}
else
{
gme_load_custom (sys->emu, ReaderStream, size, demux->s);
}
gme_start_track (sys->emu, sys->track_id = 0);
es_format_t fmt;
es_format_Init (&fmt, AUDIO_ES, VLC_CODEC_S16N);
fmt.audio.i_rate = RATE;
fmt.audio.i_bytes_per_frame = 4;
fmt.audio.i_frame_length = 4;
fmt.audio.i_channels = 2;
fmt.audio.i_blockalign = 4;
fmt.audio.i_bitspersample = 16;
fmt.i_bitrate = RATE * 4;
sys->es = es_out_Add (demux->out, &fmt);
date_Init (&sys->pts, RATE, 1);
date_Set (&sys->pts, 0);
/* Titles */
unsigned n = gme_track_count (sys->emu);
sys->titlev = malloc (n * sizeof (*sys->titlev));
if (unlikely(sys->titlev == NULL))
n = 0;
sys->titlec = n;
for (unsigned i = 0; i < n; i++)
{
input_title_t *title = vlc_input_title_New ();
sys->titlev[i] = title;
if (unlikely(title == NULL))
continue;
gme_info_t *infos;
if (gme_track_info (sys->emu, &infos, i))
continue;
msg_Dbg (obj, "track %u: %s %d ms", i, infos->song, infos->length);
if (infos->length != -1)
title->i_length = infos->length * INT64_C(1000);
if (infos->song[0])
title->psz_name = strdup (infos->song);
gme_free_info (infos);
}
/* Callbacks */
demux->pf_demux = Demux;
demux->pf_control = Control;
demux->p_sys = sys;
return VLC_SUCCESS;
}
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 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;
}
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 int
cgme_init (DB_fileinfo_t *_info, DB_playItem_t *it) {
gme_fileinfo_t *info = (gme_fileinfo_t*)_info;
int samplerate = deadbeef->conf_get_int ("synth.samplerate", 44100);
gme_err_t res = "gme uninitialized";
deadbeef->pl_lock ();
{
const char *fname = deadbeef->pl_find_meta (it, ":URI");
const char *ext = strrchr (fname, '.');
char *buffer;
int sz;
if (!read_gzfile (fname, &buffer, &sz)) {
res = gme_open_data (fname, buffer, sz, &info->emu, samplerate);
free (buffer);
}
if (res) {
DB_FILE *f = deadbeef->fopen (fname);
if (!f) {
deadbeef->pl_unlock ();
return -1;
}
int64_t sz = deadbeef->fgetlength (f);
if (sz <= 0) {
deadbeef->fclose (f);
deadbeef->pl_unlock ();
return -1;
}
char *buf = malloc (sz);
if (!buf) {
deadbeef->fclose (f);
deadbeef->pl_unlock ();
return -1;
}
int64_t rb = deadbeef->fread (buf, 1, sz, f);
deadbeef->fclose(f);
if (rb != sz) {
free (buf);
deadbeef->pl_unlock ();
return -1;
}
res = gme_open_data (fname, buf, sz, &info->emu, samplerate);
free (buf);
}
}
deadbeef->pl_unlock ();
if (res) {
trace ("failed with error %d\n", res);
return -1;
}
chip_voices = deadbeef->conf_get_int ("chip.voices", 0xff);
gme_mute_voices (info->emu, chip_voices^0xff);
gme_start_track (info->emu, deadbeef->pl_find_meta_int (it, ":TRACKNUM", 0));
gme_info_t *inf;
gme_track_info (info->emu, &inf, deadbeef->pl_find_meta_int (it, ":TRACKNUM", 0));
_info->plugin = &plugin;
_info->fmt.bps = 16;
_info->fmt.channels = 2;
_info->fmt.samplerate = samplerate;
_info->fmt.channelmask = _info->fmt.channels == 1 ? DDB_SPEAKER_FRONT_LEFT : (DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT);
info->duration = deadbeef->pl_get_item_duration (it);
info->reallength = inf->length;
_info->readpos = 0;
return 0;
}
BBString * bmx_gme_get_trackinfo(MaxMusicEmu * emu, gme_info_t ** info, int track) {
return bbStringFromCString(gme_track_info(emu->emu, info, track));
}
bool GME::open(const QString &_url, bool tracksOnly)
{
QString prefix, url, param;
const bool hasPluginPrefix = Functions::splitPrefixAndUrlIfHasPluginPrefix(_url, &prefix, &url, ¶m);
if (tracksOnly == hasPluginPrefix)
return false;
int track = 0;
if (!hasPluginPrefix)
{
if (url.startsWith(GMEName "://"))
return false;
url = _url;
}
else
{
if (prefix != GMEName)
return false;
bool ok;
track = param.toInt(&ok);
if (track < 0 || !ok)
return false;
}
if (Reader::create(url, m_reader))
{
const QByteArray data = m_reader->read(m_reader->size());
m_reader.clear();
gme_open_data(data.data(), data.size(), &m_gme, m_srate);
if (!m_gme)
return false;
if (!hasPluginPrefix)
{
m_aborted = true;
m_url = url;
return true;
}
if (track >= gme_track_count(m_gme))
return false;
gme_info_t *info = NULL;
if (!gme_track_info(m_gme, &info, track) && info)
{
m_title = getTitle(info, track);
m_length = getLength(info);
if (*info->game)
m_tags << qMakePair(QString::number(QMPLAY2_TAG_TITLE), QString(info->game));
if (*info->author)
m_tags << qMakePair(QString::number(QMPLAY2_TAG_ARTIST), QString(info->author));
if (*info->system)
m_tags << qMakePair(tr("System"), QString(info->system));
if (*info->copyright)
m_tags << qMakePair(tr("Copyright"), QString(info->copyright));
if (*info->comment)
m_tags << qMakePair(tr("Comment"), QString(info->comment));
gme_free_info(info);
}
QString voices;
const int numVoices = gme_voice_count(m_gme);
for (int i = 0; i < numVoices; ++i)
{
voices += gme_voice_name(m_gme, i);
voices += ", ";
}
voices.chop(2);
m_tags << qMakePair(tr("Voices"), voices);
m_tags << qMakePair(tr("Track"), QString::number(track + 1));
streams_info += new StreamInfo(m_srate, 2);
gme_set_stereo_depth(m_gme, 0.5);
return !gme_start_track(m_gme, track);
}
return false;
}
static gboolean
xmms_gme_init (xmms_xform_t *xform)
{
xmms_gme_data_t *data;
gme_err_t init_error;
GString *file_contents; /* The raw data from the file. */
gme_info_t *metadata = NULL;
xmms_config_property_t *val;
int loops;
int maxlength;
const char *subtune_str;
int subtune = 0;
long fadelen = -1;
int samplerate;
double stereodepth;
g_return_val_if_fail (xform, FALSE);
data = g_new0 (xmms_gme_data_t, 1);
xmms_xform_private_data_set (xform, data);
val = xmms_xform_config_lookup (xform, "samplerate");
samplerate = xmms_config_property_get_int (val);
if (samplerate < 1)
samplerate = GME_DEFAULT_SAMPLE_RATE;
data->samplerate = samplerate;
xmms_xform_outdata_type_add (xform,
XMMS_STREAM_TYPE_MIMETYPE,
"audio/pcm", /* PCM samples */
XMMS_STREAM_TYPE_FMT_FORMAT,
XMMS_SAMPLE_FORMAT_S16, /* 16-bit signed */
XMMS_STREAM_TYPE_FMT_CHANNELS,
2, /* stereo */
XMMS_STREAM_TYPE_FMT_SAMPLERATE,
samplerate,
XMMS_STREAM_TYPE_END);
file_contents = g_string_new ("");
for (;;) {
xmms_error_t error;
gchar buf[4096];
gint ret;
ret = xmms_xform_read (xform, buf, sizeof (buf), &error);
if (ret == -1) {
XMMS_DBG ("Error reading emulated music data");
return FALSE;
}
if (ret == 0) {
break;
}
g_string_append_len (file_contents, buf, ret);
}
init_error = gme_open_data (file_contents->str, file_contents->len, &data->emu, samplerate);
g_string_free (file_contents, TRUE);
if (init_error) {
XMMS_DBG ("gme_open_data returned an error: %s", init_error);
return FALSE;
}
if (xmms_xform_metadata_get_str (xform, "subtune", &subtune_str)) {
subtune = strtol (subtune_str, NULL, 10);
XMMS_DBG ("Setting subtune to %d", subtune);
if ((subtune < 0 || subtune > gme_track_count (data->emu))) {
XMMS_DBG ("Invalid subtune index");
return FALSE;
}
} else {
xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_SUBTUNES, gme_track_count (data->emu));
}
/*
* Get metadata here
*/
init_error = gme_track_info (data->emu, &metadata, subtune);
if (init_error) {
XMMS_DBG ("Couldn't get GME track info: %s", init_error);
init_error = "";
} else {
xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_TITLE, metadata->song);
xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_ARTIST, metadata->author);
xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_ALBUM, metadata->game);
xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_COMMENT, metadata->comment);
xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_YEAR, metadata->copyright);
xmms_xform_metadata_set_str (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_GENRE, metadata->system); /* I mapped genre to the system type */
val = xmms_xform_config_lookup (xform, "loops");
loops = xmms_config_property_get_int (val);
XMMS_DBG ("intro_length = %d, loops = %d, loop_length = %d", metadata->intro_length, loops, metadata->loop_length);
if (metadata->intro_length > 0) {
if ((loops > 0) && (metadata->loop_length > 0)) {
fadelen = metadata->intro_length + loops * metadata->loop_length;
XMMS_DBG ("fadelen now = %ld", fadelen);
} else {
fadelen = metadata->length;
XMMS_DBG ("fadelen now = %ld", fadelen);
}
}
}
val = xmms_xform_config_lookup (xform, "maxlength");
maxlength = xmms_config_property_get_int (val);
XMMS_DBG ("maxlength = %d seconds", maxlength);
if (maxlength > 0 && (fadelen < 0 || (maxlength * 1000L < fadelen))) {
fadelen = maxlength * 1000L;
XMMS_DBG ("fadelen now = %ld", fadelen);
}
XMMS_DBG ("gme.fadelen = %ld", fadelen);
val = xmms_xform_config_lookup (xform, "stereodepth");
stereodepth = xmms_config_property_get_float (val);
if (stereodepth >= 0.0 && stereodepth <= 1.0) {
XMMS_DBG ("Setting stereo depth to %f.", stereodepth);
gme_set_stereo_depth (data->emu, stereodepth);
} else {
XMMS_DBG ("gme.stereodepth = %f out of range 0.0 - 1.0; not setting.", stereodepth);
}
init_error = gme_start_track (data->emu, subtune);
if (init_error) {
XMMS_DBG ("gme_start_track returned an error: %s", init_error);
gme_free_info (metadata);
return FALSE;
}
if (fadelen > 0) {
XMMS_DBG ("Setting song length and fade length...");
xmms_xform_metadata_set_int (xform, XMMS_MEDIALIB_ENTRY_PROPERTY_DURATION, fadelen);
gme_set_fade (data->emu, fadelen);
}
gme_free_info (metadata);
return TRUE;
}
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 );
}
