gme_err_t Music_Player::start_track( int track ) { if ( emu_ ) { gme_free_info( track_info_ ); track_info_ = NULL; RETURN_ERR( gme_track_info( emu_, &track_info_, track ) ); // Sound must not be running when operating on emulator sound_stop(); RETURN_ERR( gme_start_track( emu_, track ) ); // Calculate track length if ( track_info_->length <= 0 ) track_info_->length = track_info_->intro_length + track_info_->loop_length * 2; if ( track_info_->length <= 0 ) track_info_->length = (long) (2.5 * 60 * 1000); gme_set_fade( emu_, track_info_->length ); paused = false; sound_start(); } return 0; }
jint Java_de_illogical_modo_SpcDecoder_spcAYfirstsong(JNIEnv* env, jclass clazz) { gme_err_t err = NULL; struct gme_info_t* trackinfo; int l = -1; if (emu == NULL) { return -1; } // i4 => Playerversion // i5 => SysPreset / Fadelength // i6 => Channels: 0 = ABC, 1 = ACB err = gme_track_info(emu, &trackinfo, 0); if (err == NULL) { l = trackinfo->firstsong; gme_free_info(trackinfo); return l; } return -1; }
Playlist::Entries GME::fetchTracks(const QString &url, bool &ok) { Playlist::Entries entries; if (open(url, true)) { const int tracks = gme_track_count(m_gme); for (int i = 0; i < tracks; ++i) { gme_info_t *info = NULL; if (!gme_track_info(m_gme, &info, i) && info) { Playlist::Entry entry; entry.url = GMEName + QString("://{%1}%2").arg(m_url).arg(i); entry.name = getTitle(info, i); entry.length = getLength(info); gme_free_info(info); entries.append(entry); } } if (entries.length() > 1) { for (int i = 0; i < entries.length(); ++i) entries[i].parent = 1; Playlist::Entry entry; entry.name = Functions::fileName(m_url, false); entry.url = m_url; entry.GID = 1; entries.prepend(entry); } } ok = !entries.isEmpty(); return entries; }
static int read_close_gme(AVFormatContext *s) { GMEContext *gme = s->priv_data; gme_free_info(gme->info); gme_delete(gme->music_emu); return 0; }
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; }
JNIEXPORT jboolean JNICALL Java_com_ssb_droidsound_plugins_GMEPlugin_N_1setTune(JNIEnv *env, jobject obj, jlong song, jint tune) { GMEInfo *info = (GMEInfo*)song; gme_err_t err = gme_start_track(info->emu, tune); info->started = true; gme_info_t* track; err = gme_track_info(info->emu, &track, tune); gme_free_info(info->lastTrack); info->lastTrack = track; __android_log_print(ANDROID_LOG_VERBOSE, "GMEPlugin", "SetTune '%s' -> %s %d", err, track->song, track->length); info->currentSong = tune; return true; }
bool GMESong::GetTrackInfo() { gme_err_t err; if (TrackInfo != NULL) { gme_free_info(TrackInfo); TrackInfo = NULL; } err = gme_track_info(Emu, &TrackInfo, CurrTrack); if (err != NULL) { Printf("Could not get track %d info: %s\n", CurrTrack, err); return false; } return true; }
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(); }
jint Java_de_illogical_modo_SpcDecoder_spcGetTrackInfoLength(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; }
jlong Java_de_illogical_modo_GmeDecoder_gmeTrackLength(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); }
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 ); }
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; }
gme_err_t gme_track_info( Music_Emu const* me, gme_info_t** out, int track ) { *out = NULL; gme_info_t_* info = BLARGG_NEW gme_info_t_; CHECK_ALLOC( info ); gme_err_t err = me->track_info( &info->info, track ); if ( err ) { gme_free_info( info ); return err; } #define COPY(name) info->name = info->info.name; COPY( length ); COPY( intro_length ); COPY( loop_length ); COPY( fade_length ); info->i5 = -1; info->i6 = -1; info->i7 = -1; info->i8 = -1; info->i9 = -1; info->i10 = -1; info->i11 = -1; info->i12 = -1; info->i13 = -1; info->i14 = -1; info->i15 = -1; info->s7 = ""; info->s8 = ""; info->s9 = ""; info->s10 = ""; info->s11 = ""; info->s12 = ""; info->s13 = ""; info->s14 = ""; info->s15 = ""; COPY( system ); COPY( game ); COPY( song ); COPY( author ); COPY( copyright ); COPY( comment ); COPY( dumper ); #undef COPY info->play_length = info->length; if ( info->play_length <= 0 ) { info->play_length = info->intro_length + 2 * info->loop_length; // intro + 2 loops if ( info->play_length <= 0 ) info->play_length = 150 * 1000; // 2.5 minutes } *out = info; return blargg_ok; }
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 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; }
void bmx_gme_trackinfo_free(gme_info_t * info) { gme_free_info(info); }
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; }
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 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; }
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; }
Music_Player::~Music_Player() { stop(); sound_cleanup(); gme_free_info( track_info_ ); }