int xmp_load_typed_module_from_memory(xmp_context opaque, void *mem, long size, const struct format_loader* format)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
HIO_HANDLE *h;
int ret;
if ((h = hio_open_mem(mem, size)) == NULL)
return -XMP_ERROR_SYSTEM;
m->filename = NULL;
m->basename = NULL;
m->size = size;
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
load_prologue(ctx);
D_(D_WARN "load");
ret = -XMP_ERROR_FORMAT;
if (format->test(h, NULL, 0) == 0) {
if ((ret = module_load(h, ctx, format)))
xmp_release_module(opaque);
}
hio_close(h);
return ret;
}
int main(int argc, char **argv)
{
xmp_context ctx1, ctx2;
struct xmp_module_info mi1, mi2;
int res1, res2;
/* create player 1 */
ctx1 = xmp_create_context();
if (xmp_load_module(ctx1, argv[1]) < 0) {
fprintf(stderr, "%s: error loading %s\n", argv[0], argv[1]);
exit(1);
}
xmp_start_player(ctx1, 44100, 0);
xmp_get_module_info(ctx1, &mi1);
printf("1: %s (%s)\n", mi1.mod->name, mi1.mod->type);
/* play a bit of file 1 */
res1 = xmp_play_frame(ctx1);
/* create player 2 */
ctx2 = xmp_create_context();
if (xmp_load_module(ctx2, argv[2]) < 0) {
fprintf(stderr, "%s: error loading %s\n", argv[0], argv[2]);
exit(1);
}
xmp_start_player(ctx2, 44100, 0);
xmp_get_module_info(ctx2, &mi2);
printf("2: %s (%s)\n", mi2.mod->name, mi2.mod->type);
/* play file 2 */
res2 = xmp_play_frame(ctx2);
/* play file 1 again */
res1 = xmp_play_frame(ctx1);
/* close player 1 */
xmp_end_player(ctx1);
/* play file 2 again */
res1 = xmp_play_frame(ctx2);
/* close player 2 */
xmp_end_player(ctx2);
xmp_release_module(ctx1);
xmp_release_module(ctx2);
xmp_free_context(ctx1);
xmp_free_context(ctx2);
return 0;
}
int xmp_load_module_from_file(xmp_context opaque, void *file, long size)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
HIO_HANDLE *h;
FILE *f = fdopen(fileno((FILE *)file), "rb");
int ret;
if ((h = hio_open_file(f)) == NULL)
return -XMP_ERROR_SYSTEM;
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
m->filename = NULL;
m->basename = NULL;
m->dirname = NULL;
m->size = hio_size(h);
ret = load_module(opaque, h);
hio_close(h);
return ret;
}
int xmp_load_module_from_memory(xmp_context opaque, void *mem, long size)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
HIO_HANDLE *h;
int ret;
/* Use size < 0 for unknown/undetermined size */
if (size == 0)
size--;
if ((h = hio_open_mem(mem, size)) == NULL)
return -XMP_ERROR_SYSTEM;
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
m->filename = NULL;
m->basename = NULL;
m->dirname = NULL;
m->size = size;
ret = load_module(opaque, h);
hio_close(h);
return ret;
}
int main() {
xmp_context ctx;
struct xmp_frame_info fi;
int i, j;
FILE *t = fopen("test.tmp", "wb+");
ctx = xmp_create_context();
xmp_load_module(ctx, "../tests/3d.mod");
xmp_start_player(ctx, 44100, 0);
for (i=0;i<300;i++) {
xmp_play_frame(ctx);
xmp_get_frame_info(ctx, &fi);
for (j=0;j<fi.buffer_size;j++) {
fputc(((char *)fi.buffer)[j], t);
}
}
printf("Dumped sound to `test.tmp`\n");
xmp_end_player(ctx);
xmp_release_module(ctx);
xmp_free_context(ctx);
fclose(t);
printf("Start playing...\n");
system("aplay test.tmp --rate=44100 -f cd");
printf("Deleting file...\n");
unlink("test.tmp");
return 0;
}
/**
* Stop the current music.
*/
void stopMusic () {
// Stop the music playing
SDL_PauseAudio(~0);
#if defined(USE_MODPLUG)
if (musicFile) {
ModPlug_Unload(musicFile);
musicFile = NULL;
}
#elif defined(USE_XMP)
int state = xmp_get_player(xmpC, XMP_PLAYER_STATE);
if (state == XMP_STATE_LOADED || state == XMP_STATE_PLAYING) {
xmp_end_player(xmpC);
xmp_release_module(xmpC);
}
#endif
SDL_PauseAudio(0);
return;
}
static void get_song_info(char *filename, char **title, int *length)
{
xmp_context ctx2;
int lret;
struct xmp_module_info mi;
struct xmp_options *opt;
/* Create new context to load a file and get the length */
ctx2 = xmp_create_context();
opt = xmp_get_options(ctx2);
opt->skipsmp = 1; /* don't load samples */
pthread_mutex_lock(&load_mutex);
lret = xmp_load_module(ctx2, filename);
pthread_mutex_unlock(&load_mutex);
if (lret < 0) {
xmp_free_context(ctx2);
return;
}
*length = lret;
xmp_get_module_info(ctx2, &mi);
*title = g_strdup(mi.name);
xmp_release_module(ctx2);
xmp_free_context(ctx2);
}
int xmp_load_module(xmp_context opaque, char *path)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
HIO_HANDLE *h;
struct stat st;
struct list_head tmpfiles_list;
D_(D_WARN "path = %s", path);
if (stat(path, &st) < 0)
return -XMP_ERROR_SYSTEM;
#ifndef _MSC_VER
if (S_ISDIR(st.st_mode)) {
errno = EISDIR;
return -XMP_ERROR_SYSTEM;
}
#endif
if ((h = hio_open_file(path, "rb")) == NULL)
return -XMP_ERROR_SYSTEM;
INIT_LIST_HEAD(&tmpfiles_list);
D_(D_INFO "decrunch");
if (decrunch(&tmpfiles_list, &h->f, &path, DECRUNCH_MAX) < 0)
goto err_depack;
if (hio_stat(h, &st) < 0)
goto err_depack;
if (st.st_size < 256) { /* get size after decrunch */
hio_close(h);
unlink_tempfiles(&tmpfiles_list);
return -XMP_ERROR_FORMAT;
}
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
m->dirname = get_dirname(path);
if (m->dirname == NULL)
return -XMP_ERROR_SYSTEM;
m->basename = get_basename(path);
if (m->basename == NULL)
return -XMP_ERROR_SYSTEM;
m->filename = path; /* For ALM, SSMT, etc */
m->size = st.st_size;
return load_module(opaque, h, &tmpfiles_list);
err_depack:
hio_close(h);
unlink_tempfiles(&tmpfiles_list);
return -XMP_ERROR_DEPACK;
}
static void S_XMP_CodecCloseStream (snd_stream_t *stream)
{
xmp_context c = (xmp_context)stream->priv;
xmp_end_player(c);
xmp_release_module(c);
xmp_free_context(c);
S_CodecUtilClose(&stream);
}
void xmp_free_context(xmp_context opaque)
{
struct context_data *ctx = (struct context_data *)opaque;
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
free(opaque);
}
static int load_module(xmp_context opaque, HIO_HANDLE *h, struct list_head *tmpfiles_list)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
int i, ret;
int test_result, load_result;
load_prologue(ctx);
D_(D_WARN "load");
test_result = load_result = -1;
for (i = 0; format_loader[i] != NULL; i++) {
hio_seek(h, 0, SEEK_SET);
test_result = format_loader[i]->test(h, NULL, 0);
if (test_result == 0) {
hio_seek(h, 0, SEEK_SET);
D_(D_WARN "load format: %s", format_loader[i]->name);
load_result = format_loader[i]->loader(m, h, 0);
break;
}
}
if (test_result == 0 && load_result == 0)
set_md5sum(h, m->md5);
hio_close(h);
if (tmpfiles_list != NULL)
unlink_tempfiles(tmpfiles_list);
if (test_result < 0) {
free(m->basename);
free(m->dirname);
return -XMP_ERROR_FORMAT;
}
if (load_result < 0) {
xmp_release_module(opaque);
return -XMP_ERROR_LOAD;
}
str_adj(m->mod.name);
load_epilogue(ctx);
ret = prepare_scan(ctx);
if (ret < 0)
return ret;
scan_sequences(ctx);
ctx->state = XMP_STATE_LOADED;
return 0;
}
int main(int argc, char **argv)
{
xmp_context ctx;
struct xmp_module_info mi;
struct xmp_frame_info fi;
int i;
ctx = xmp_create_context();
if (sdl_init(ctx) < 0) {
fprintf(stderr, "%s: can't initialize sound\n", argv[0]);
exit(1);
}
for (i = 1; i < argc; i++) {
if (xmp_load_module(ctx, argv[i]) < 0) {
fprintf(stderr, "%s: error loading %s\n", argv[0],
argv[i]);
continue;
}
if (xmp_start_player(ctx, 44100, 0) == 0) {
/* Show module data */
xmp_get_module_info(ctx, &mi);
printf("%s (%s)\n", mi.mod->name, mi.mod->type);
/* Play module */
playing = 1;
SDL_PauseAudio(0);
while (playing) {
SDL_Delay(10);
xmp_get_frame_info(ctx, &fi);
printf("%3d/%3d %3d/%3d\r", fi.pos,
mi.mod->len, fi.row, fi.num_rows);
fflush(stdout);
}
xmp_end_player(ctx);
}
xmp_release_module(ctx);
printf("\n");
}
xmp_free_context(ctx);
sdl_deinit();
return 0;
}
static void *play_loop(void *arg)
{
xmp_play_module(ctx);
xmp_release_module(ctx);
xmp_close_audio(ctx);
playing = 0;
_D("--- pthread_exit");
pthread_exit(NULL);
return NULL;
}
static qboolean S_XMP_CodecOpenStream (snd_stream_t *stream)
{
/* need to load the whole file into memory and pass it to libxmp
* using xmp_load_module_from_memory() which requires libxmp >= 4.2.
* libxmp-4.0/4.1 only have xmp_load_module() which accepts a file
* name which isn't good with files in containers like paks, etc. */
xmp_context c;
byte *moddata;
long len;
int mark;
c = xmp_create_context();
if (c == NULL)
return false;
len = FS_filelength (&stream->fh);
mark = Hunk_LowMark();
moddata = (byte *) Hunk_Alloc(len);
FS_fread(moddata, 1, len, &stream->fh);
if (xmp_load_module_from_memory(c, moddata, len) != 0)
{
Con_DPrintf("Could not load module %s\n", stream->name);
goto err1;
}
Hunk_FreeToLowMark(mark); /* free original file data */
stream->priv = c;
if (shm->speed > XMP_MAX_SRATE)
stream->info.rate = 44100;
else if (shm->speed < XMP_MIN_SRATE)
stream->info.rate = 11025;
else stream->info.rate = shm->speed;
stream->info.bits = shm->samplebits;
stream->info.width = stream->info.bits / 8;
stream->info.channels = shm->channels;
if (S_XMP_StartPlay(stream) != 0)
goto err2;
/* percentual left/right channel separation, default is 70. */
if (stream->info.channels == 2)
if (xmp_set_player(c, XMP_PLAYER_MIX, 100) != 0)
goto err3;
/* interpolation type, default is XMP_INTERP_LINEAR */
if (xmp_set_player(c, XMP_PLAYER_INTERP, XMP_INTERP_SPLINE) != 0)
goto err3;
return true;
err3: xmp_end_player(c);
err2: xmp_release_module(c);
err1: xmp_free_context(c);
return false;
}
static gpointer play_loop(gpointer arg)
{
InputPlayback *ipb = arg;
xmp_play_module(ctx);
xmp_release_module(ctx);
xmp_close_audio(ctx);
ipb->eof = 1;
ipb->playing = 0;
return NULL;
}
JNIEXPORT jobject JNICALL
Java_org_helllabs_android_xmp_Xmp_getModInfo(JNIEnv *env, jobject obj, jstring fname)
{
const char *filename;
int res;
xmp_context ctx2;
struct xmp_options *opt;
struct xmp_module_info mi;
jobject modInfo;
jmethodID cid;
jclass modInfoClass;
jstring name, type;
modInfoClass = (*env)->FindClass(env, "org/helllabs/android/xmp/ModInfo");
if (modInfoClass == NULL)
return NULL;
filename = (*env)->GetStringUTFChars(env, fname, NULL);
ctx2 = xmp_create_context();
opt = xmp_get_options(ctx2);
opt->skipsmp = 1; /* don't load samples */
res = xmp_load_module(ctx2, (char *)filename);
(*env)->ReleaseStringUTFChars(env, fname, filename);
if (res < 0) {
xmp_free_context(ctx2);
return NULL;
}
xmp_get_module_info(ctx2, &mi);
xmp_release_module(ctx2);
xmp_free_context(ctx2);
/*__android_log_print(ANDROID_LOG_DEBUG, "libxmp", "%s", mi.name);
__android_log_print(ANDROID_LOG_DEBUG, "libxmp", "%s", mi.type);*/
name = (*env)->NewStringUTF(env, mi.name);
type = (*env)->NewStringUTF(env, mi.type);
cid = (*env)->GetMethodID(env, modInfoClass,
"<init>",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IIIIIIIII)V");
modInfo = (*env)->NewObject(env, modInfoClass, cid,
name, type, fname,
mi.chn, mi.pat, mi.ins, mi.trk, mi.smp, mi.len,
mi.bpm, mi.tpo, mi.time);
return modInfo;
}
static void load_tester(xmp_context ctx, const char *path)
{
xmp_file f;
void *moddata;
size_t modsize;
int ret;
f = xmp_fopen(path, "rb");
modsize = xmp_fsize(f);
moddata = malloc(modsize);
xmp_fread(moddata, 1, modsize, f);
xmp_fclose(f);
f = xmp_fopen_mem(moddata, modsize);
ret = xmp_load_module_f(ctx, f, "data/unknown");
fail_unless(ret == 0, "load file");
xmp_fclose(f);
xmp_release_module(ctx);
free(moddata);
}
int main(int argc, char **argv)
{
xmp_context c;
struct xmp_frame_info mi;
FILE *f;
/* The output raw file */
f = fopen("out.raw", "wb");
if (f == NULL) {
fprintf(stderr, "can't open output file\n");
exit(EXIT_FAILURE);
}
/* Create the player context */
c = xmp_create_context();
/* Load our module */
if (xmp_load_module(c, argv[1]) != 0) {
fprintf(stderr, "can't load module\n");
exit(EXIT_FAILURE);
}
/* Play the module */
xmp_start_player(c, 44100, 0);
while (xmp_play_frame(c) == 0) {
xmp_get_frame_info(c, &mi);
if (mi.loop_count > 0) /* exit before looping */
break;
fwrite(mi.buffer, mi.buffer_size, 1, stdout); /* write audio data */
}
xmp_end_player(c);
xmp_release_module(c); /* unload module */
xmp_free_context(c); /* destroy the player context */
fclose(f);
exit(EXIT_SUCCESS);
}
static Tuple *get_song_tuple(char *filename)
{
Tuple *tuple;
xmp_context ctx2;
int lret;
struct xmp_module_info mi;
struct xmp_options *opt;
strip_vfs(filename); /* Sorry, no VFS support */
tuple = aud_tuple_new_from_filename(filename);
/* Create new context to load a file and get the length */
ctx2 = xmp_create_context();
opt = xmp_get_options(ctx2);
opt->skipsmp = 1; /* don't load samples */
g_static_mutex_lock(&load_mutex);
lret = xmp_load_module(ctx2, filename);
g_static_mutex_unlock(&load_mutex);
if (lret < 0) {
xmp_free_context(ctx2);
return NULL;
}
xmp_get_module_info(ctx2, &mi);
aud_tuple_associate_string(tuple, FIELD_TITLE, NULL, mi.name);
aud_tuple_associate_string(tuple, FIELD_CODEC, NULL, mi.type);
aud_tuple_associate_int(tuple, FIELD_LENGTH, NULL, lret);
xmp_release_module(ctx2);
xmp_free_context(ctx2);
return tuple;
}
JNIEXPORT jint JNICALL
Java_org_helllabs_android_xmp_Xmp_releaseModule(JNIEnv *env, jobject obj)
{
xmp_release_module(ctx);
return 0;
}
int xmp_create_module(xmp_context opaque, int nch)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
struct xmp_module *mod = &m->mod;
int i;
if (nch < 0 || nch > 64)
return -XMP_ERROR_INVALID;
m->filename = NULL;
m->basename = NULL;
m->size = 0;
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
load_prologue(ctx);
mod->pat = 1;
mod->len = mod->pat;
mod->ins = 0;
mod->smp = 0;
mod->chn = nch;
mod->trk = mod->pat * mod->chn;
mod->xxo[0] = 0;
mod->xxp = calloc(mod->pat, sizeof (struct xmp_pattern *));
if (mod->xxp == NULL)
goto err;
mod->xxt = calloc(mod->trk, sizeof (struct xmp_track *));
if (mod->xxt == NULL)
goto err1;
for (i = 0; i < mod->pat; i++) {
mod->xxp[i] = calloc(1, sizeof (struct xmp_pattern) +
(nch - 1) * sizeof(int));
if (mod->xxp[i] == NULL)
goto err2;
mod->xxp[i]->rows = 64;
}
for (i = 0; i < mod->trk; i++) {
mod->xxt[i] = calloc(1, sizeof (struct xmp_track) +
(mod->xxp[0]->rows - 1) * sizeof (struct xmp_event));
if (mod->xxt[i] == NULL)
goto err3;
mod->xxp[i / nch]->index[i % nch] = i;
mod->xxt[i] = calloc (sizeof (struct xmp_track) + sizeof
(struct xmp_event) * (mod->xxp[i / nch]->rows - 1), 1);
mod->xxt[i]->rows = 64;
}
load_epilogue(ctx);
ret = prepare_scan(ctx);
if (ret < 0)
return ret;
scan_sequences(ctx);
ctx->state = XMP_STATE_LOADED;
return 0;
err3:
for (i = 0; i < mod->trk; i++)
free(mod->xxt[i]);
err2:
for (i = 0; i < mod->pat; i++)
free(mod->xxp[i]);
free(mod->xxt);
err1:
free(mod->xxp);
err:
return XMP_ERROR_INTERNAL;
}
int xmp_load_module(xmp_context opaque, char *path)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
HIO_HANDLE *h;
struct stat st;
struct list_head tmpfiles_list;
int test_result, load_result;
int i, ret;
D_(D_WARN "path = %s", path);
if (stat(path, &st) < 0)
return -XMP_ERROR_SYSTEM;
#ifndef _MSC_VER
if (S_ISDIR(st.st_mode)) {
errno = EISDIR;
return -XMP_ERROR_SYSTEM;
}
#endif
if ((h = hio_open_file(path, "rb")) == NULL)
return -XMP_ERROR_SYSTEM;
INIT_LIST_HEAD(&tmpfiles_list);
D_(D_INFO "decrunch");
if (decrunch(&tmpfiles_list, &h->f, &path, DECRUNCH_MAX) < 0)
goto err_depack;
if (hio_stat(h, &st) < 0)
goto err_depack;
if (st.st_size < 256) { /* get size after decrunch */
hio_close(h);
unlink_tempfiles(&tmpfiles_list);
return -XMP_ERROR_FORMAT;
}
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
m->dirname = get_dirname(path);
if (m->dirname == NULL)
return -XMP_ERROR_SYSTEM;
m->basename = get_basename(path);
if (m->basename == NULL)
return -XMP_ERROR_SYSTEM;
m->filename = path; /* For ALM, SSMT, etc */
m->size = st.st_size;
load_prologue(ctx);
D_(D_WARN "load");
test_result = load_result = -1;
for (i = 0; format_loader[i] != NULL; i++) {
hio_seek(h, 0, SEEK_SET);
test_result = format_loader[i]->test(h, NULL, 0);
if (test_result == 0) {
hio_seek(h, 0, SEEK_SET);
D_(D_WARN "load format: %s", format_loader[i]->name);
load_result = format_loader[i]->loader(m, h, 0);
break;
}
}
set_md5sum(h, m->md5);
hio_close(h);
unlink_tempfiles(&tmpfiles_list);
if (test_result < 0) {
free(m->basename);
free(m->dirname);
return -XMP_ERROR_FORMAT;
}
if (load_result < 0) {
xmp_release_module(opaque);
return -XMP_ERROR_LOAD;
}
str_adj(m->mod.name);
if (!*m->mod.name) {
strncpy(m->mod.name, m->basename, XMP_NAME_SIZE);
}
load_epilogue(ctx);
ret = prepare_scan(ctx);
if (ret < 0)
return ret;
scan_sequences(ctx);
ctx->state = XMP_STATE_LOADED;
return 0;
err_depack:
hio_close(h);
unlink_tempfiles(&tmpfiles_list);
return -XMP_ERROR_DEPACK;
}
static int load_module(xmp_context opaque, HIO_HANDLE *h)
{
struct context_data *ctx = (struct context_data *)opaque;
struct module_data *m = &ctx->m;
struct xmp_module *mod = &m->mod;
int i, j, ret;
int test_result, load_result;
load_prologue(ctx);
D_(D_WARN "load");
test_result = load_result = -1;
for (i = 0; format_loader[i] != NULL; i++) {
hio_seek(h, 0, SEEK_SET);
D_(D_WARN "test %s", format_loader[i]->name);
test_result = format_loader[i]->test(h, NULL, 0);
if (test_result == 0) {
hio_seek(h, 0, SEEK_SET);
D_(D_WARN "load format: %s", format_loader[i]->name);
load_result = format_loader[i]->loader(m, h, 0);
break;
}
}
#ifndef LIBXMP_CORE_PLAYER
if (test_result == 0 && load_result == 0)
set_md5sum(h, m->md5);
#endif
if (test_result < 0) {
free(m->basename);
free(m->dirname);
return -XMP_ERROR_FORMAT;
}
if (load_result < 0) {
goto err_load;
}
/* Sanity check */
if (mod->chn > XMP_MAX_CHANNELS || mod->len > XMP_MAX_MOD_LENGTH) {
goto err_load;
}
/* Sanity check */
if (mod->xxp == NULL) {
goto err_load;
}
for (i = 0; i < mod->pat; i++) {
if (mod->xxp[i] == NULL) {
goto err_load;
}
for (j = 0; j < mod->chn; j++) {
int t = mod->xxp[i]->index[j];
if (t < 0 || t >= mod->trk || mod->xxt[t] == NULL) {
goto err_load;
}
}
}
adjust_string(mod->name);
load_epilogue(ctx);
ret = prepare_scan(ctx);
if (ret < 0) {
xmp_release_module(opaque);
return ret;
}
scan_sequences(ctx);
ctx->state = XMP_STATE_LOADED;
return 0;
err_load:
xmp_release_module(opaque);
return -XMP_ERROR_LOAD;
}
int main(int argc, char **argv)
{
xmp_context ctx;
struct xmp_module_info mi;
struct xmp_frame_info fi;
int row, pos, i;
if (sound_init(44100, 2) < 0) {
fprintf(stderr, "%s: can't initialize sound\n", argv[0]);
exit(1);
}
ctx = xmp_create_context();
for (i = 1; i < argc; i++) {
if (xmp_load_module(ctx, argv[i]) < 0) {
fprintf(stderr, "%s: error loading %s\n", argv[0],
argv[i]);
continue;
}
if (xmp_start_player(ctx, 44100, 0) == 0) {
/* Show module data */
xmp_get_module_info(ctx, &mi);
printf("%s (%s)\n", mi.mod->name, mi.mod->type);
/* Play module */
row = pos = -1;
while (xmp_play_frame(ctx) == 0) {
xmp_get_frame_info(ctx, &fi);
if (fi.loop_count > 0)
break;
sound_play(fi.buffer, fi.buffer_size);
if (fi.pos != pos) {
printf("\n%02x:%02x\n",
fi.pos, fi.pattern);
pos = fi.pos;
row = -1;
}
if (fi.row != row) {
display_data(&mi, &fi);
row = fi.row;
}
}
xmp_end_player(ctx);
}
xmp_release_module(ctx);
printf("\n");
}
xmp_free_context(ctx);
sound_deinit();
return 0;
}
int xmp_load_module(xmp_context opaque, char *path)
{
struct context_data *ctx = (struct context_data *)opaque;
#ifndef LIBXMP_CORE_PLAYER
struct module_data *m = &ctx->m;
long size;
char *temp_name;
#endif
HIO_HANDLE *h;
struct stat st;
int ret;
D_(D_WARN "path = %s", path);
/*
if (stat(path, &st) < 0)
return -XMP_ERROR_SYSTEM;
*/
#ifndef _MSC_VER
if (S_ISDIR(st.st_mode)) {
errno = EISDIR;
return -XMP_ERROR_SYSTEM;
}
#endif
if ((h = hio_open(path, "rb")) == NULL)
return -XMP_ERROR_SYSTEM;
#ifndef LIBXMP_CORE_PLAYER
D_(D_INFO "decrunch");
if (decrunch(&h, path, &temp_name) < 0)
goto err_depack;
size = hio_size(h);
if (size < 256) { /* get size after decrunch */
hio_close(h);
unlink_temp_file(temp_name);
return -XMP_ERROR_FORMAT;
}
#endif
if (ctx->state > XMP_STATE_UNLOADED)
xmp_release_module(opaque);
#ifndef LIBXMP_CORE_PLAYER
m->dirname = get_dirname(path);
if (m->dirname == NULL)
return -XMP_ERROR_SYSTEM;
m->basename = get_basename(path);
if (m->basename == NULL)
return -XMP_ERROR_SYSTEM;
m->filename = path; /* For ALM, SSMT, etc */
m->size = size;
#endif
ret = load_module(opaque, h);
hio_close(h);
#ifndef LIBXMP_CORE_PLAYER
unlink_temp_file(temp_name);
#endif
return ret;
#ifndef LIBXMP_CORE_PLAYER
err_depack:
hio_close(h);
unlink_temp_file(temp_name);
return -XMP_ERROR_DEPACK;
#endif
}
static void _compare_mixer_data(char *mod, char *data, int loops, int ignore_rv)
{
xmp_context opaque;
struct context_data *ctx;
struct module_data *m;
struct player_data *p;
struct mixer_voice *vi;
struct xmp_frame_info fi;
int time, row, frame, chan, period, note, ins, vol, pan, pos0, cutoff;
char line[200];
FILE *f;
int i, voc, ret;
f = fopen(data, "r");
fail_unless(f != NULL, "can't open data file");
opaque = xmp_create_context();
fail_unless(opaque != NULL, "can't create context");
ret = xmp_load_module(opaque, mod);
fail_unless(ret == 0, "can't load module");
ctx = (struct context_data *)opaque;
m = &ctx->m;
p = &ctx->p;
xmp_start_player(opaque, 44100, 0);
xmp_set_player(opaque, XMP_PLAYER_MIX, 100);
while (1) {
xmp_play_frame(opaque);
xmp_get_frame_info(opaque, &fi);
if (fi.loop_count >= loops)
break;
for (i = 0; i < m->mod.chn; i++) {
struct xmp_channel_info *ci = &fi.channel_info[i];
struct channel_data *xc = &p->xc_data[i];
int num;
voc = map_channel(p, i);
if (voc < 0 || TEST_NOTE(NOTE_SAMPLE_END))
continue;
vi = &p->virt.voice_array[voc];
fgets(line, 200, f);
num = sscanf(line, "%d %d %d %d %d %d %d %d %d %d %d",
&time, &row, &frame, &chan, &period,
¬e, &ins, &vol, &pan, &pos0, &cutoff);
fail_unless(fi.time == time, "time mismatch");
fail_unless(fi.row == row, "row mismatch");
fail_unless(fi.frame == frame, "frame mismatch");
fail_unless(i == chan, "channel mismatch");
fail_unless(ci->period == period, "period mismatch");
fail_unless(vi->note == note, "note mismatch");
fail_unless(vi->ins == ins, "instrument");
if (!ignore_rv) {
fail_unless(vi->vol == vol, "volume mismatch");
fail_unless(vi->pan == pan, "pan mismatch");
}
fail_unless(vi->pos0 == pos0, "position mismatch");
if (num >= 11) {
fail_unless(vi->filter.cutoff == cutoff,
"cutoff mismatch");
}
}
}
fgets(line, 200, f);
fail_unless(feof(f), "not end of data file");
xmp_end_player(opaque);
xmp_release_module(opaque);
xmp_free_context(opaque);
}
UObject* USoundModImporterFactory::FactoryCreateBinary
(
UClass* Class,
UObject* InParent,
FName Name,
EObjectFlags Flags,
UObject* Context,
const TCHAR* FileType,
const uint8*& Buffer,
const uint8* BufferEnd,
FFeedbackContext* Warn
)
{
// if the sound already exists, remember the user settings
USoundMod* ExistingSound = FindObject<USoundMod>(InParent, *Name.ToString());
// TODO - Audio Threading. This needs to be sent to the audio device and wait on stopping the sounds
TArray<UAudioComponent*> ComponentsToRestart;
FAudioDevice* AudioDevice = GEngine->GetAudioDevice();
if (AudioDevice && ExistingSound)
{
// TODO: Generalize the stop sounds function
//AudioDevice->StopSoundsForReimport(ExistingSound, ComponentsToRestart);
}
bool bUseExistingSettings = bSoundModFactorySuppressImportOverwriteDialog;
if (ExistingSound && !bUseExistingSettings && !GIsAutomationTesting)
{
DisplayOverwriteOptionsDialog(FText::Format(
NSLOCTEXT("SoundModImporterFactory", "ImportOverwriteWarning", "You are about to import '{0}' over an existing sound."),
FText::FromName(Name)));
switch (OverwriteYesOrNoToAllState)
{
case EAppReturnType::Yes:
case EAppReturnType::YesAll:
{
// Overwrite existing settings
bUseExistingSettings = false;
break;
}
case EAppReturnType::No:
case EAppReturnType::NoAll:
{
// Preserve existing settings
bUseExistingSettings = true;
break;
}
default:
{
FEditorDelegates::OnAssetPostImport.Broadcast(this, NULL);
return NULL;
}
}
}
// Reset the flag back to false so subsequent imports are not suppressed unless the code explicitly suppresses it
bSoundModFactorySuppressImportOverwriteDialog = false;
TArray<uint8> RawModData;
RawModData.Empty(BufferEnd - Buffer);
RawModData.AddUninitialized(BufferEnd - Buffer);
FMemory::Memcpy(RawModData.GetData(), Buffer, RawModData.Num());
// TODO: Validate that this is actually a mod file
xmp_context xmpContext = xmp_create_context();
if (xmp_load_module_from_memory(xmpContext, RawModData.GetData(), RawModData.Num()) != 0)
{
return NULL;
}
xmp_module_info xmpModuleInfo;
xmp_get_module_info(xmpContext, &xmpModuleInfo);
// Use pre-existing sound if it exists and we want to keep settings,
// otherwise create new sound and import raw data.
USoundMod* Sound = (bUseExistingSettings && ExistingSound) ? ExistingSound : NewObject<USoundMod>(InParent, Name, Flags);
Sound->Duration = xmpModuleInfo.seq_data->duration / 1000.f;
xmp_release_module(xmpContext);
xmp_free_context(xmpContext);
Sound->RawData.Lock(LOCK_READ_WRITE);
void* LockedData = Sound->RawData.Realloc(BufferEnd - Buffer);
FMemory::Memcpy(LockedData, Buffer, BufferEnd - Buffer);
Sound->RawData.Unlock();
FEditorDelegates::OnAssetPostImport.Broadcast(this, Sound);
for (int32 ComponentIndex = 0; ComponentIndex < ComponentsToRestart.Num(); ++ComponentIndex)
{
ComponentsToRestart[ComponentIndex]->Play();
}
return Sound;
}