void Java_de_illogical_modo_GmeDecoder_gmeSetStereoSeparation(JNIEnv* env, jclass clazz, jint d)
{
depth = d/100.0;
if (depth < 0.0)
depth = 0.0;
if (depth > 1.0)
depth = 1.0;
if (emu != NULL)
gme_set_stereo_depth(emu, depth);
}
jint Java_de_illogical_modo_GmeDecoder_gmeSetTrack(JNIEnv* env, jclass clazz, jint track)
{
if (emu == NULL)
{
return -1;
}
gme_ignore_silence(emu, 1);
gme_start_track(emu, track);
gme_set_stereo_depth(emu, depth);
return 1;
}
jint Java_de_illogical_modo_GmeDecoder_gmeLoadFile(JNIEnv* env, jclass clazz, jstring path)
{
char cpath[1024];
memset(cpath, 0, 1024);
int clen = (*env)->GetStringLength(env, path);
if (clen > 1023)
return 0;
(*env)->GetStringUTFRegion(env, path, 0, clen, cpath);
gme_err_t err = gme_open_file(cpath, &emu, 44100);
if (err != NULL)
{
emu = NULL;
}
else
{
gme_start_track(emu, 0);
gme_set_stereo_depth(emu, depth);
}
return emu != 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 Music_Player::set_stereo_depth( double tempo )
{
suspend();
gme_set_stereo_depth( emu_, tempo );
resume();
}
void bmx_gme_set_stereo_depth(MaxMusicEmu * emu, double depth) {
gme_set_stereo_depth(emu->emu, depth);
}
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;
}
jint Java_de_illogical_modo_GmeDecoder_gmeLoadFromZip(JNIEnv* env, jclass clazz, jstring zipfile, jstring entry, int vgzfile)
{
char* data = NULL;
int size = 0;
char czipfile[1024];
char centry[1024];
memset(czipfile, 0, 1024);
int clen = (*env)->GetStringLength(env, zipfile);
if (clen > 1023)
return 0;
(*env)->GetStringUTFRegion(env, zipfile, 0, clen, czipfile);
memset(centry, 0, 1024);
clen = (*env)->GetStringLength(env, entry);
if (clen > 1023)
return 0;
(*env)->GetStringUTFRegion(env, entry, 0, clen, centry);
data = getUncompressedData(czipfile, centry, &size);
if (data == NULL)
return 0;
// If its a .vgz file inflate it. Problem is, can go up to 10MB. GME copies data = 20MB.
// kss can also be gzip
if (size > 10 && data[0] == 0x1F && data[1] == 0x8B) {
unsigned long uncompressed_size = data[size-1] << 24 | data[size-2] << 16 | data[size-3] << 8 | data[size-4];
char* inflatebuffer = malloc(uncompressed_size);
if (inflatebuffer != NULL) {
int err;
z_stream zs;
zs.zalloc = Z_NULL;
zs.zfree = Z_NULL;
zs.opaque = Z_NULL;
zs.next_in = data;
zs.avail_in = size;
zs.next_out = inflatebuffer;
zs.avail_out = uncompressed_size;
inflateInit2(&zs, 16 + MAX_WBITS);
err = inflate(&zs, Z_FINISH);
if (err == Z_STREAM_END) {
//__android_log_print(ANDROID_LOG_VERBOSE, "gme", "-> ZLIB STREAM END - extracted Bytes %ld", zs.total_out);
size = zs.total_out;
free(data);
data = inflatebuffer;
} else {
free(inflatebuffer);
}
inflateEnd(&zs);
}
}
// GME copies memory
gme_err_t err = gme_open_data(data, size, &emu, 44100);
free(data);
if (err != NULL)
{
emu = NULL;
}
else
{
gme_start_track(emu, 0);
gme_set_stereo_depth(emu, depth);
}
if (emu != NULL)
return size;
return 0;
}
