static int alm_load(struct module_data *m, HIO_HANDLE *f, const int start)
{
struct xmp_module *mod = &m->mod;
int i, j;
struct alm_file_header afh;
struct xmp_event *event;
struct stat stat;
uint8 b;
char *basename;
char filename[NAME_SIZE];
char modulename[NAME_SIZE];
LOAD_INIT();
hio_read(&afh.id, 7, 1, f);
if (!strncmp((char *)afh.id, "ALEYMOD", 7)) /* Version 1.0 */
mod->spd = afh.speed / 2;
strncpy(modulename, m->filename, NAME_SIZE);
basename = strtok (modulename, ".");
afh.speed = hio_read8(f);
afh.length = hio_read8(f);
afh.restart = hio_read8(f);
hio_read(&afh.order, 128, 1, f);
mod->len = afh.length;
mod->rst = afh.restart;
memcpy (mod->xxo, afh.order, mod->len);
for (mod->pat = i = 0; i < mod->len; i++)
if (mod->pat < afh.order[i])
mod->pat = afh.order[i];
mod->pat++;
mod->ins = 31;
mod->trk = mod->pat * mod->chn;
mod->smp = mod->ins;
m->c4rate = C4_NTSC_RATE;
set_type(m, "Aley's Module");
MODULE_INFO();
if (pattern_init(mod) < 0)
return -1;
/* Read and convert patterns */
D_(D_INFO "Stored patterns: %d", mod->pat);
for (i = 0; i < mod->pat; i++) {
if (pattern_tracks_alloc(mod, i, 64) < 0)
return -1;
for (j = 0; j < 64 * mod->chn; j++) {
event = &EVENT (i, j % mod->chn, j / mod->chn);
b = hio_read8(f);
if (b)
event->note = (b == 37) ? 0x61 : b + 48;
event->ins = hio_read8(f);
}
}
if (instrument_init(mod) < 0)
return -1;
/* Read and convert instruments and samples */
D_(D_INFO "Loading samples: %d", mod->ins);
for (i = 0; i < mod->ins; i++) {
HIO_HANDLE *s;
if (subinstrument_alloc(mod, i, 1) < 0)
return -1;
mod->xxi[i].sub = calloc(sizeof (struct xmp_subinstrument), 1);
snprintf(filename, NAME_SIZE, "%s.%d", basename, i + 1);
s = hio_open(filename, "rb");
if (s == NULL)
continue;
mod->xxi[i].nsm = 1;
hio_stat(s, &stat);
b = hio_read8(s); /* Get first octet */
mod->xxs[i].len = stat.st_size - 5 * !b;
if (!b) { /* Instrument with header */
mod->xxs[i].lps = hio_read16l(f);
mod->xxs[i].lpe = hio_read16l(f);
mod->xxs[i].flg = mod->xxs[i].lpe > mod->xxs[i].lps ? XMP_SAMPLE_LOOP : 0;
} else {
hio_seek(s, 0, SEEK_SET);
}
mod->xxi[i].sub[0].pan = 0x80;
mod->xxi[i].sub[0].vol = 0x40;
mod->xxi[i].sub[0].sid = i;
D_(D_INFO "[%2X] %-14.14s %04x %04x %04x %c V%02x", i,
filename, mod->xxs[i].len, mod->xxs[i].lps, mod->xxs[i].lpe,
mod->xxs[i].flg & XMP_SAMPLE_LOOP ? 'L' : ' ', mod->xxi[i].sub[0].vol);
if (load_sample(m, s, SAMPLE_FLAG_UNS, &mod->xxs[i], NULL) < 0)
return -1;
hio_close(s);
}
/* ALM is LRLR, not LRRL */
for (i = 0; i < mod->chn; i++)
mod->xxc[i].pan = DEFPAN((i % 2) * 0xff);
return 0;
}
int
main(int argc,
char ** argv)
{
char * pmi_rank = getenv("PMI_RANK");
char * hio_name = getenv("STUB_NAME");
int rank = -1;
int status;
if (argc != 2) {
printf("Usage: %s <file to open>\n", *argv);
return -1;
}
if (pmi_rank == NULL) {
printf("No PMI_RANK in env. assuming rank 0\n");
rank = 0;
} else {
rank = atoi(pmi_rank);
}
if (hio_name == NULL) {
printf("No STUB_NAME in env. exiting\n");
return -1;
}
sleep(2);
status = libhio_client_init(hio_name, rank);
if (status != 0) {
printf("Failed to init HIO client\n");
return -1;
}
/* Open/read/write/close a file */
{
char * file_name = argv[1];
int fd;
ssize_t bytes;
off_t offset;
char buf[PAGE_SIZE * 10];
fd = hio_open(file_name, O_RDONLY);
if (hio_status != HIO_SUCCESS || fd < 0) {
printf("Could not open file %s (fd=%d)\n", file_name, fd);
goto out;
}
bytes = hio_read(fd, buf, PAGE_SIZE * 10);
printf("Read %li bytes from fd %d\n", bytes, fd);
if (bytes> 0)
printf("%s\n", buf);
hio_close(fd);
fd = hio_open(file_name, O_WRONLY | O_TRUNC);
if (hio_status != HIO_SUCCESS || fd < 0) {
printf("Could not open file %s (fd=%d)\n", file_name, fd);
goto out;
}
bytes = hio_write(fd, "Overwrite file\n", 15);
printf("Wrote %li bytes to fd %d\n", bytes, fd);
hio_close(fd);
}
/* mmap the file */
{
char * file_name = argv[1];
int fd;
ssize_t bytes;
off_t offset;
void * addr;
void * at_addr;
hio_segment_t seg;
fd = hio_open(file_name, O_RDONLY);
if (hio_status != HIO_SUCCESS || fd < 0) {
printf("Could not open file %s (fd=%d)\n", file_name, fd);
goto out;
}
addr = hio_mmap(NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0, &seg);
if (hio_status != HIO_SUCCESS || addr == MAP_FAILED) {
printf("failed to issue mmap to fd: %d\n", fd);
goto out;
}
/* Linux mapped new memory to'addr'. We do not have this region
* mapped in our aspace, so we need to map it in now
*/
status = __map_hio_segment(&seg, MY_ID);
if (status != 0) {
printf("Failed to target the mmap to the stub-allocated vaddr\n");
goto out;
}
addr = seg.vaddr;
printf("at %p: %s\n", addr, (char *)addr);
hio_close(fd);
}
out:
libhio_client_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 int mfp_load(struct module_data *m, HIO_HANDLE *f, const int start)
{
struct xmp_module *mod = &m->mod;
int i, j, k, x, y;
struct xmp_event *event;
struct stat st;
char smp_filename[PATH_MAX];
HIO_HANDLE *s;
int size1 /*, size2*/;
int pat_addr, pat_table[128][4];
uint8 buf[1024], mod_event[4];
int row;
LOAD_INIT();
libxmp_set_type(m, "Magnetic Fields Packer");
MODULE_INFO();
mod->chn = 4;
mod->ins = mod->smp = 31;
if (libxmp_init_instrument(m) < 0)
return -1;
for (i = 0; i < 31; i++) {
int loop_size;
if (libxmp_alloc_subinstrument(mod, i, 1) < 0)
return -1;
mod->xxs[i].len = 2 * hio_read16b(f);
mod->xxi[i].sub[0].fin = (int8)(hio_read8(f) << 4);
mod->xxi[i].sub[0].vol = hio_read8(f);
mod->xxs[i].lps = 2 * hio_read16b(f);
loop_size = hio_read16b(f);
mod->xxs[i].lpe = mod->xxs[i].lps + 2 * loop_size;
mod->xxs[i].flg = loop_size > 1 ? XMP_SAMPLE_LOOP : 0;
mod->xxi[i].sub[0].pan = 0x80;
mod->xxi[i].sub[0].sid = i;
mod->xxi[i].rls = 0xfff;
if (mod->xxs[i].len > 0)
mod->xxi[i].nsm = 1;
D_(D_INFO "[%2X] %04x %04x %04x %c V%02x %+d",
i, mod->xxs[i].len, mod->xxs[i].lps,
mod->xxs[i].lpe,
loop_size > 1 ? 'L' : ' ',
mod->xxi[i].sub[0].vol, mod->xxi[i].sub[0].fin >> 4);
}
mod->len = mod->pat = hio_read8(f);
hio_read8(f); /* restart */
for (i = 0; i < 128; i++) {
mod->xxo[i] = hio_read8(f);
}
if (hio_error(f)) {
return -1;
}
mod->trk = mod->pat * mod->chn;
/* Read and convert patterns */
if (libxmp_init_pattern(mod) < 0)
return -1;
size1 = hio_read16b(f);
/* size2 = */ hio_read16b(f);
for (i = 0; i < size1; i++) { /* Read pattern table */
for (j = 0; j < 4; j++) {
pat_table[i][j] = hio_read16b(f);
}
}
D_(D_INFO "Stored patterns: %d ", mod->pat);
pat_addr = hio_tell(f);
for (i = 0; i < mod->pat; i++) {
if (libxmp_alloc_pattern_tracks(mod, i, 64) < 0)
return -1;
for (j = 0; j < 4; j++) {
hio_seek(f, pat_addr + pat_table[i][j], SEEK_SET);
hio_read(buf, 1, 1024, f);
for (row = k = 0; k < 4; k++) {
for (x = 0; x < 4; x++) {
for (y = 0; y < 4; y++, row++) {
event = &EVENT(i, j, row);
memcpy(mod_event, &buf[buf[buf[buf[k] + x] + y] * 2], 4);
libxmp_decode_protracker_event(event, mod_event);
}
}
}
}
}
/* Read samples */
D_(D_INFO "Loading samples: %d", mod->ins);
/* first check smp.filename */
if (strlen(m->basename) < 5 || m->basename[3] != '.') {
fprintf(stderr, "libxmp: invalid filename %s\n", m->basename);
goto err;
}
m->basename[0] = 's';
m->basename[1] = 'm';
m->basename[2] = 'p';
snprintf(smp_filename, PATH_MAX, "%s%s", m->dirname, m->basename);
if (stat(smp_filename, &st) < 0) {
/* handle .set filenames like in Kid Chaos*/
char *x;
if (strchr(m->basename, '-')) {
if ((x = strrchr(smp_filename, '-')))
strcpy(x, ".set");
}
if (stat(smp_filename, &st) < 0) {
fprintf(stderr, "libxmp: missing file %s\n",
smp_filename);
goto err;
}
}
if ((s = hio_open(smp_filename, "rb")) == NULL) {
fprintf(stderr, "libxmp: can't open sample file %s\n",
smp_filename);
goto err;
}
for (i = 0; i < mod->ins; i++) {
if (libxmp_load_sample(m, s, SAMPLE_FLAG_FULLREP,
&mod->xxs[mod->xxi[i].sub[0].sid], NULL) < 0) {
free(s);
return -1;
}
}
hio_close(s);
m->period_type = PERIOD_MODRNG;
return 0;
err:
for (i = 0; i < mod->ins; i++) {
mod->xxi[i].nsm = 0;
memset(&mod->xxs[i], 0, sizeof(struct xmp_sample));
}
return 0;
}
int xmp_test_module(char *path, struct xmp_test_info *info)
{
HIO_HANDLE *h;
struct stat st;
char buf[XMP_NAME_SIZE];
int i;
int ret = -XMP_ERROR_FORMAT;
#ifndef LIBXMP_CORE_PLAYER
char *temp = NULL;
#endif
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
if (decrunch(&h, path, &temp) < 0) {
ret = -XMP_ERROR_DEPACK;
goto err;
}
/* get size after decrunch */
if (hio_size(h) < 256) { /* set minimum valid module size */
ret = -XMP_ERROR_FORMAT;
goto err;
}
#endif
if (info != NULL) {
*info->name = 0; /* reset name prior to testing */
*info->type = 0; /* reset type prior to testing */
}
for (i = 0; format_loader[i] != NULL; i++) {
hio_seek(h, 0, SEEK_SET);
if (format_loader[i]->test(h, buf, 0) == 0) {
int is_prowizard = 0;
#ifndef LIBXMP_CORE_PLAYER
if (strcmp(format_loader[i]->name, "prowizard") == 0) {
hio_seek(h, 0, SEEK_SET);
pw_test_format(h, buf, 0, info);
is_prowizard = 1;
}
#endif
fclose(h->handle.file);
#ifndef LIBXMP_CORE_PLAYER
unlink_temp_file(temp);
#endif
if (info != NULL && !is_prowizard) {
strncpy(info->name, buf, XMP_NAME_SIZE);
strncpy(info->type, format_loader[i]->name,
XMP_NAME_SIZE);
}
return 0;
}
}
#ifndef LIBXMP_CORE_PLAYER
err:
hio_close(h);
unlink_temp_file(temp);
#else
hio_close(h);
#endif
return ret;
}