SOUNDCLIP *my_load_mp3(const char *filname, int voll)
{
mp3in = pack_fopen(filname, "rb");
if (mp3in == NULL)
return NULL;
char *tmpbuffer = (char *)malloc(MP3CHUNKSIZE);
if (tmpbuffer == NULL) {
pack_fclose(mp3in);
return NULL;
}
thistune = new MYMP3();
thistune->in = mp3in;
thistune->chunksize = MP3CHUNKSIZE;
thistune->filesize = mp3in->todo;
thistune->done = 0;
thistune->vol = voll;
if (thistune->chunksize > mp3in->todo)
thistune->chunksize = mp3in->todo;
pack_fread(tmpbuffer, thistune->chunksize, mp3in);
thistune->buffer = (char *)tmpbuffer;
_mp3_mutex.Lock();
thistune->stream = almp3_create_mp3stream(tmpbuffer, thistune->chunksize, (mp3in->todo < 1));
_mp3_mutex.Unlock();
if (thistune->stream == NULL) {
free(tmpbuffer);
pack_fclose(mp3in);
delete thistune;
return NULL;
}
return thistune;
}
/*! \brief Load game
*
* Uh-huh.
* PH 20030805 Made endian-safe
* PH 20030914 Now ignores keyboard settings etc in the save file
* \returns 1 if load succeeded, 0 otherwise
*/
static int load_game (void)
{
PACKFILE *sdat;
int a;
unsigned char tv;
sprintf (strbuf, "sg%d.sav", save_ptr);
sdat = pack_fopen (kqres (SAVE_DIR, strbuf), F_READ_PACKED);
if (!sdat) {
message (_("Could not load saved game."), 255, 0, 0, 0);
return 0;
}
tv = pack_getc (sdat);
if (tv == 92)
a = load_game_92(sdat);
else if (tv == 91)
a = load_game_91(sdat);
else {
a = 0;
message (_("Saved game format is not current."), 255, 0, 0, 0);
}
pack_fclose (sdat);
if (!a)
return 0;
timer_count = 0;
ksec = 0;
hold_fade = 0;
change_map (curmap, g_ent[0].tilex, g_ent[0].tiley, g_ent[0].tilex,
g_ent[0].tiley);
/* Set music and sound volume */
set_volume (gsvol, -1);
set_music_volume (((float) gmvol) / 255.0);
return 1;
}
PACKFILE *file_handle(char code_letter)
{
static PACKFILE *file = NULL;
static char current_code_letter = 0;
char file_name[30];
if (code_letter == 0)
{
current_code_letter = 0;
if (file != NULL)
pack_fclose(file);
file = NULL;
}
else if (code_letter != current_code_letter)
{
if (file != NULL)
{
pack_fclose(file);
file = NULL;
}
sprintf(file_name, "%s#%ccodes", code_defs_file_name, tolower(code_letter));
packfile_password(PASSWORD);
file = pack_fopen(file_name, F_READ_PACKED);
packfile_password(NULL);
current_code_letter = code_letter;
}
if (file == NULL)
return NULL;
if (pack_feof(file) == TRUE)
return NULL;
return file;
}
/*! \brief Save game 92
*
* Save the game, using KQ Save Game Format 92 (Beta)
* Author: Winter Knight
*
* \returns 0 if save failed, 1 if success
*/
static int save_game_92 (void)
{
size_t a, b, c, d;
PACKFILE *sdat;
for (b = 0; b < PSIZE; b++) {
sid[save_ptr][b] = 0;
shp[save_ptr][b] = 0;
smp[save_ptr][b] = 0;
slv[save_ptr][b] = 0;
}
for (b = 0; b < numchrs; b++) {
sid[save_ptr][b] = pidx[b];
shp[save_ptr][b] = party[pidx[b]].hp * 100 / party[pidx[b]].mhp;
if (party[pidx[b]].mmp > 0)
smp[save_ptr][b] = party[pidx[b]].mp * 100 / party[pidx[b]].mmp;
slv[save_ptr][b] = party[pidx[b]].lvl;
}
snc[save_ptr] = numchrs;
sgp[save_ptr] = gp;
smin[save_ptr] = kmin;
shr[save_ptr] = khr;
sprintf (strbuf, "sg%d.sav", save_ptr);
sdat = pack_fopen (kqres (SAVE_DIR, strbuf), F_WRITE_PACKED);
if (!sdat) {
message (_("Could not save game data."), 255, 0, 0, 0);
return 0;
}
pack_putc (kq_version, sdat);
pack_iputl (gp, sdat);
pack_iputw (shr[save_ptr], sdat);
pack_iputw (smin[save_ptr], sdat);
/* Save number of, and which characters are in the party */
pack_iputw (numchrs, sdat);
for (a = 0; a < numchrs; a++) {
pack_iputw (pidx[a], sdat);
}
/* Save number of, and data on all characters in game */
pack_iputw (MAXCHRS, sdat);
for (a = 0; a < MAXCHRS; a++) {
save_s_player (&party[a], sdat);
}
/* Save map name and location */
pack_iputw (strlen (curmap), sdat);
pack_fwrite (curmap, strlen (curmap), sdat);
pack_iputw (g_ent[0].tilex, sdat);
pack_iputw (g_ent[0].tiley, sdat);
/* Save quest info */
for (a = sizeof (progress); a > 0; a--) {
if (progress[a - 1] > 0)
break;
}
pack_iputw (a, sdat);
for (b = 0; b < a; b++)
pack_putc (progress[b], sdat);
/* Save treasure info */
for (a = sizeof (treasure); a > 0; a--) {
if (treasure[a - 1] > 0)
break;
}
pack_iputw (a, sdat);
for (b = 0; b < a; b++)
pack_putc (treasure[b], sdat);
/* Save spell info (P_REPULSE is 48) */
pack_iputw (sizeof (save_spells), sdat);
for (a = 0; a < sizeof (save_spells); a++) { /* sizeof(save_spells) is 50 */
pack_putc (save_spells[a], sdat);
}
/* Save player inventory */
pack_iputw (MAX_INV, sdat);
for (a = 0; a < MAX_INV; a++) {
pack_iputw (g_inv[a][0], sdat);
pack_iputw (g_inv[a][1], sdat);
}
/* Save special items */
for (a = MAX_SPECIAL_ITEMS + 1; a > 0; a--) {
if (player_special_items[a - 1])
break;
}
pack_iputw (a, sdat);
for (b = 0; b < a; b++) {
pack_putc (player_special_items[b], sdat);
}
/* Save shop info (last visit time and number of items) */
/* Find last index of shop that the player has visited. */
for (a = num_shops; a > 0; a--) {
if (shop_time[a - 1] > 0)
break;
}
pack_iputw (a, sdat);
for (b = 0; b < a; b++) {
pack_iputw (shop_time[b], sdat);
/* Find last valid (non-zero) shop item for this shop */
for (c = SHOPITEMS; c > 0; c--)
if (shops[b].items[c - 1] > 0)
break;
pack_iputw (c, sdat);
for (d = 0; d < c; d++)
pack_iputw (shops[b].items_current[d], sdat);
}
pack_fclose (sdat);
return 1;
}
/*! \brief Save game
*
* You guessed it... save the game.
*
* \returns 0 if save failed, 1 if success
*/
static int save_game (void)
{
PACKFILE *sdat;
size_t a, b;
return save_game_92 ();
/* Rest of this function is no longer used */
for (b = 0; b < PSIZE; b++) {
sid[save_ptr][b] = 0;
shp[save_ptr][b] = 0;
smp[save_ptr][b] = 0;
slv[save_ptr][b] = 0;
}
for (b = 0; b < numchrs; b++) {
sid[save_ptr][b] = pidx[b];
shp[save_ptr][b] = party[pidx[b]].hp * 100 / party[pidx[b]].mhp;
if (party[pidx[b]].mmp > 0)
smp[save_ptr][b] = party[pidx[b]].mp * 100 / party[pidx[b]].mmp;
slv[save_ptr][b] = party[pidx[b]].lvl;
}
snc[save_ptr] = numchrs;
sgp[save_ptr] = gp;
smin[save_ptr] = kmin;
shr[save_ptr] = khr;
sprintf (strbuf, "sg%d.sav", save_ptr);
sdat = pack_fopen (kqres (SAVE_DIR, strbuf), F_WRITE_PACKED);
if (!sdat) {
message (_("Could not save game data."), 255, 0, 0, 0);
return 0;
}
pack_putc (kq_version, sdat);
pack_iputl (numchrs, sdat);
pack_iputl (gp, sdat);
pack_iputl (shr[save_ptr], sdat);
pack_iputl (smin[save_ptr], sdat);
for (a = 0; a < PSIZE; a++) {
pack_iputl (pidx[a], sdat);
}
for (a = 0; a < MAXCHRS; a++) {
save_s_player (&party[a], sdat);
}
pack_fwrite (curmap, 16, sdat);
for (a = 0; a < sizeof (progress); a++) { /* sizeof(progress) is 1750 */
pack_putc (progress[a], sdat);
}
for (a = 0; a < NUMSHOPS; a++) { /* NUMSHOPS is 50 */
pack_putc (shop_time[a], sdat);
}
for (a = 0; a < SIZE_SAVE_RESERVE1; a++) { /* SAVE_RESERVE_SIZE1 is 150 */
pack_putc (0, sdat);
}
for (a = 0; a < sizeof (save_spells); a++) { /* sizeof(save_spells) is 50 */
pack_putc (save_spells[a], sdat);
}
for (a = 0; a < sizeof (treasure); a++) { /* sizeof(treasure) is 1000 */
pack_putc (treasure[a], sdat);
}
for (a = 0; a < NUMSHOPS; a++) {
for (b = 0; b < SHOPITEMS; b++) {
pack_iputw (shops[a].items_current[b], sdat);
}
}
for (a = 0; a < MAX_INV; a++) {
pack_iputw (g_inv[a][0], sdat);
pack_iputw (g_inv[a][1], sdat);
}
/* PH FIXME: do we _really_ want things like controls and screen */
/* mode to be saved/loaded ? */
/* WK: No. */
pack_iputl (gsvol, sdat);
pack_iputl (gmvol, sdat);
pack_putc (windowed, sdat);
pack_putc (stretch_view, sdat);
pack_putc (wait_retrace, sdat);
pack_iputl (kup, sdat);
pack_iputl (kdown, sdat);
pack_iputl (kleft, sdat);
pack_iputl (kright, sdat);
pack_iputl (kalt, sdat);
pack_iputl (kctrl, sdat);
pack_iputl (kenter, sdat);
pack_iputl (kesc, sdat);
pack_iputl (jbalt, sdat);
pack_iputl (jbctrl, sdat);
pack_iputl (jbenter, sdat);
pack_iputl (jbesc, sdat);
/* End worthless */
pack_iputw (g_ent[0].tilex, sdat);
pack_iputw (g_ent[0].tiley, sdat);
pack_fclose (sdat);
return 1;
}
/*! \brief Load mini stats
*
* This loads the mini stats for each saved game.
* These mini stats are just for displaying info about the save game on the
* save/load game screen.
*/
void load_sgstats (void)
{
PACKFILE *ldat;
int a, b, c;
unsigned char vc;
s_player tpm;
for (a = 0; a < NUMSG; a++) {
sprintf (strbuf, "sg%d.sav", a);
ldat = pack_fopen (kqres (SAVE_DIR, strbuf), F_READ_PACKED);
if (!ldat) {
snc[a] = 0;
sgp[a] = 0;
shr[a] = 0;
smin[a] = 0;
for (b = 0; b < PSIZE; b++) {
sid[a][b] = 0;
shp[a][b] = 0;
smp[a][b] = 0;
}
} else {
vc = pack_getc (ldat);
if (vc == 92) {
sgp[a] = pack_igetl (ldat);
shr[a] = pack_igetw (ldat);
smin[a] = pack_igetw (ldat);
snc[a] = pack_igetw (ldat);
for (b = 0; b < snc[a]; b++) {
sid[a][b] = pack_igetw (ldat);
// sid[a][b] = 0; // Temp: Debugging / Testing
}
pack_igetw (ldat); // Number of characters in game. Assume MAXCHRS
for (b = 0; b < MAXCHRS; b++) {
load_s_player (&tpm, ldat);
for (c = 0; c < snc[a]; c++) {
if (b == sid[a][c]) {
slv[a][c] = tpm.lvl;
shp[a][c] = tpm.hp * 100 / tpm.mhp;
if (tpm.mmp > 0)
smp[a][c] = tpm.mp * 100 / tpm.mmp;
else
smp[a][c] = 0;
}
}
}
} else if (vc == 91) {
snc[a] = pack_igetl (ldat);
sgp[a] = pack_igetl (ldat);
shr[a] = pack_igetl (ldat);
smin[a] = pack_igetl (ldat);
for (b = 0; b < PSIZE; b++) {
sid[a][b] = pack_igetl (ldat);
}
for (b = 0; b < MAXCHRS; b++) {
load_s_player (&tpm, ldat);
for (c = 0; c < PSIZE; c++) {
if (b == sid[a][c]) {
slv[a][c] = tpm.lvl;
shp[a][c] = tpm.hp * 100 / tpm.mhp;
if (tpm.mmp > 0)
smp[a][c] = tpm.mp * 100 / tpm.mmp;
else
smp[a][c] = 0;
}
}
}
} else
snc[a] = -1;
pack_fclose (ldat);
}
}
}
PACKFILE *pack_fopen_password(const char *filename, const char *mode, const char *password) {
packfile_password(password);
PACKFILE *result = pack_fopen(filename, mode);
packfile_password("");
return result;
}
void update_file(char *filename, char *dataname)
{
PACKFILE *f, *ef, *df = NULL;
char *tmpname;
int c;
#ifdef ALLEGRO_HAVE_MKSTEMP
char tmp_buf[] = "XXXXXX";
char tmp[512];
int tmp_fd;
tmp_fd = mkstemp(tmp_buf);
close(tmp_fd);
tmpname = uconvert_ascii(tmp_buf, tmp);
#else
tmpname = tmpnam(NULL);
#endif
get_stats();
if (!err) {
if ((!stat_hasdata) && (!dataname)) {
fprintf(stderr, "%s has no appended data: cannot remove it\n", filename);
err = 1;
return;
}
rename_file(filename, tmpname);
ef = pack_fopen(tmpname, F_READ);
if (!ef) {
delete_file(tmpname);
fprintf(stderr, "Error reading temporary file\n");
err = 1;
return;
}
f = pack_fopen(filename, F_WRITE);
if (!f) {
pack_fclose(ef);
rename_file(tmpname, filename);
fprintf(stderr, "Error writing to %s\n", filename);
err = 1;
return;
}
#ifdef ALLEGRO_UNIX
chmod(filename, stat_stat.st_mode);
#endif
for (c=0; c<stat_exe_size; c++)
pack_putc(pack_getc(ef), f);
pack_fclose(ef);
delete_file(tmpname);
if (dataname) {
if (stat_hasdata)
printf("replacing %d bytes of currently appended data\n", stat_uncompressed_size);
if (opt_allegro) {
printf("reading %s as Allegro format compressed data\n", dataname);
df = pack_fopen(dataname, F_READ_PACKED);
}
else if (opt_binary) {
printf("reading %s as raw binary data\n", dataname);
df = pack_fopen(dataname, F_READ);
}
else {
printf("autodetecting format of %s: ", dataname);
df = pack_fopen(dataname, F_READ_PACKED);
if (df) {
printf("Allegro compressed data\n");
}
else {
df = pack_fopen(dataname, F_READ);
if (df)
printf("raw binary data\n");
else
printf("\n");
}
}
if (!df) {
pack_fclose(f);
fprintf(stderr, "Error opening %s\n", dataname);
err = 1;
return;
}
f = pack_fopen_chunk(f, opt_compress);
while ((c = pack_getc(df)) != EOF)
pack_putc(c, f);
f = pack_fclose_chunk(f);
pack_mputl(F_EXE_MAGIC, f);
pack_mputl(_packfile_filesize+16, f);
printf("%s has been appended onto %s\n"
"original executable size: %d bytes (%dk)\n"
"appended data size: %d bytes (%dk)\n"
"compressed into: %d bytes (%dk)\n"
"ratio: %d%%\n",
dataname, filename,
stat_exe_size, stat_exe_size/1024,
_packfile_datasize, _packfile_datasize/1024,
_packfile_filesize, _packfile_filesize/1024,
(_packfile_datasize) ? _packfile_filesize*100/_packfile_datasize : 0);
}
else {
printf("%d bytes of appended data removed from %s\n", stat_uncompressed_size, filename);
}
pack_fclose(f);
pack_fclose(df);
}
}
int eof_undo_load_state(const char * fn)
{
EOF_SONG * sp = NULL;
PACKFILE * fp = NULL, * rfp = NULL;
char rheader[16] = {0};
int old_eof_silence_loaded = eof_silence_loaded; //Retain this value, since it is destroyed by eof_destroy_song()
char eof_recover_path[50];
eof_log("eof_undo_load_state() entered", 1);
if(fn == NULL)
{
return 0;
}
fp = pack_fopen(fn, "r");
if(!fp)
{
return 0;
}
if(pack_fread(rheader, 16, fp) != 16)
{
(void) pack_fclose(fp);
return 0; //Return error if 16 bytes cannot be read
}
sp = eof_create_song(); //Initialize an empty chart
if(sp == NULL)
{
(void) pack_fclose(fp);
return 0;
}
sp->tags->accurate_ts = 0; //For existing projects, this setting must be manually enabled in order to prevent unwanted alteration to beat timings
(void) snprintf(eof_recover_path, sizeof(eof_recover_path) - 1, "%seof.recover", eof_temp_path_s);
rfp = pack_fopen(eof_recover_path, "r"); //Open the recovery file to prevent eof_destroy_song() from deleting it
if(!eof_load_song_pf(sp, fp))
{ //If loading the undo state fails
allegro_message("Failed to perform undo");
(void) pack_fclose(rfp); //Close this recovery file handle so that it will be deleted by the following call to eof_destroy_song()
eof_destroy_song(sp);
(void) pack_fclose(fp);
return 0; //Return failure
}
(void) pack_fclose(fp);
if(EOF_TRACK_PRO_GUITAR_B >= sp->tracks)
{ //If the chart loaded does not contain a bonus pro guitar track (a pre 1.8RC12 chart or a post 1.8RC12 chart with an empty bonus track during save)
if(eof_song_add_track(sp, &eof_default_tracks[EOF_TRACK_PRO_GUITAR_B]) == 0) //Add a blank bonus pro guitar track
{ //If the track failed to be added
allegro_message("Failed to perform undo");
(void) pack_fclose(rfp); //Close this recovery file handle so that it will be deleted by the following call to eof_destroy_song()
eof_destroy_song(sp);
return 0; //Return failure
}
}
if(eof_song)
{
eof_undo_in_progress = 1; //Signal to eof_destroy_song() that the waveform and spectrogram are not to be destroyed along with the active project structure
eof_destroy_song(eof_song); //Destroy the chart that is open
eof_undo_in_progress = 0;
}
(void) pack_fclose(rfp); //Calls to eof_destroy_song() are finished, the recovery file handle can be released now
eof_song = sp; //Replacing it with the loaded undo state
eof_silence_loaded = old_eof_silence_loaded; //Restore the status of whether chart audio is loaded
return 1;
}
int
main(int argc, char **argv)
{
BITMAP *bmp;
PACKFILE *f;
char *file = NULL, *times = NULL, *memory = NULL;
int arg, i, n, start, end, size;
allegro_init();
install_keyboard();
install_timer();
jpgalleg_init();
set_color_conversion(COLORCONV_NONE);
for (arg = 1; arg < argc; arg++) {
if (!strcmp(argv[arg], "-nommx"))
cpu_capabilities &= ~CPU_MMX;
else if (!strcmp(argv[arg], "-f"))
file = argv[++arg];
else if (!times)
times = argv[arg];
else
about();
}
if (times)
n = atoi(times);
else
n = 30;
if (!file)
file = "jpgalleg.jpg";
bmp = load_jpg(file, NULL);
if (!bmp) {
printf("Cannot find %s!\n", file);
return -1;
}
size = file_size(file);
memory = (char *)malloc(size);
if (!memory) {
printf("Not enough memory!\n");
return -1;
}
f = pack_fopen(file, F_READ);
pack_fread(memory, size, f);
pack_fclose(f);
LOCK_FUNCTION(timer_handler);
LOCK_VARIABLE(timer);
install_int(timer_handler, 10);
printf("Average timing for %d function calls:\n", n);
start = timer;
for (i = 0; i < n; i++)
bmp = load_jpg(file, NULL);
end = timer;
printf("load_jpg: %f seconds\n", ((float)end - (float)start) / 1000.0 / (float)n);
start = timer;
for (i = 0; i < n; i++)
bmp = load_memory_jpg(memory, size, NULL);
end = timer;
printf("load_memory_jpg: %f seconds\n", ((float)end - (float)start) / 1000.0 / (float)n);
free(memory);
return 0;
}
/* save_png:
* Writes a non-interlaced, no-frills PNG, taking the usual save_xyz
* parameters. Returns non-zero on error.
*/
int save_png(AL_CONST char *filename, BITMAP *bmp, AL_CONST RGB *pal)
{
PACKFILE *fp;
png_structp png_ptr;
png_infop info_ptr;
int depth, colour_type;
depth = bitmap_color_depth(bmp);
if ((!bmp) || ((depth == 8) && (!pal)))
return -1;
fp = pack_fopen(filename, "w");
if (!fp)
return -1;
/* Create and initialize the png_struct with the
* desired error handler functions.
*/
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(void *)NULL, NULL, NULL);
if (!png_ptr) {
pack_fclose(fp);
return -1;
}
/* Allocate/initialize the image information data. */
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
pack_fclose(fp);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return -1;
}
/* Set error handling. */
if (setjmp(png_ptr->jmpbuf)) {
/* If we get here, we had a problem reading the file. */
pack_fclose(fp);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return -1;
}
/* Use packfile routines. */
png_set_write_fn(png_ptr, fp, (png_rw_ptr)write_data, flush_data);
/* Set the image information here. Width and height are up to 2^31,
* bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
* the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
* PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
* or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
* PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
* currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE.
*/
if (depth == 8)
colour_type = PNG_COLOR_TYPE_PALETTE;
// [OMAR] No alpha
//else if (depth == 32)
//colour_type = PNG_COLOR_TYPE_RGB_ALPHA;
else
colour_type = PNG_COLOR_TYPE_RGB;
png_set_IHDR(png_ptr, info_ptr, bmp->w, bmp->h, 8, colour_type,
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
PNG_FILTER_TYPE_BASE);
/* Set the palette if there is one. Required for indexed-color images. */
if (colour_type == PNG_COLOR_TYPE_PALETTE) {
png_color palette[256];
int i;
for (i = 0; i < 256; i++) {
palette[i].red = _rgb_scale_6[pal[i].r]; /* 64 -> 256 */
palette[i].green = _rgb_scale_6[pal[i].g];
palette[i].blue = _rgb_scale_6[pal[i].b];
}
/* Set palette colors. */
png_set_PLTE(png_ptr, info_ptr, palette, 256);
}
/* Optionally write comments into the image ... Nah. */
/* Write the file header information. */
png_write_info(png_ptr, info_ptr);
/* Once we write out the header, the compression type on the text
* chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or
* PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again
* at the end.
*/
/* Flip BGR pixels to RGB. */
/*if (depth >= 24) {
if (makecol24(255, 0, 0) > makecol24(0, 0, 255))
png_set_bgr(png_ptr);
}*/
/* Set compression level. */
png_set_compression_level(png_ptr, _png_compression_level);
/* Save the data. */
if ((depth == 15) || (depth == 16)) {
if (!save_hicolour(png_ptr, bmp, depth)) {
pack_fclose(fp);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return -1;
}
}
else if (depth == 32) {
if (!save_truecolour(png_ptr, bmp)) {
pack_fclose(fp);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return -1;
}
}
else
png_write_image(png_ptr, bmp->line); /* Dirt cheap! */
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
pack_fclose(fp);
return 0;
}
/* _unix_load_modules:
* Find a modules.lst file and load the modules listed in it.
*/
void _unix_load_modules(int system_driver)
{
PACKFILE *f;
char fullpath[1024];
char *fullpath_slash;
char buf[1024];
char buf2[1024];
char **pathptr;
char *filename;
void *handle;
void (*init)(int);
MODULE *m;
/* Read the ALLEGRO_MODULES environment variable.
* But don't do it if we are root (for obvious reasons).
*/
if (geteuid() != 0) {
char *env = getenv("ALLEGRO_MODULES");
if (env) {
snprintf(fullpath, sizeof fullpath, "%s/%s", env, "modules.lst");
fullpath[(sizeof fullpath) - 1] = 0;
f = pack_fopen(uconvert_ascii(fullpath, buf), F_READ);
if (f)
goto found;
}
}
for (pathptr = module_path; *pathptr; pathptr++) {
snprintf(fullpath, sizeof fullpath, "%s/%d.%d.%d/modules.lst",
*pathptr, ALLEGRO_VERSION, ALLEGRO_SUB_VERSION, ALLEGRO_WIP_VERSION);
fullpath[(sizeof fullpath) - 1] = 0;
f = pack_fopen(uconvert_ascii(fullpath, buf), F_READ);
if (f)
goto found;
}
return;
found:
TRACE(PREFIX_I "Loading modules from \"%s\".\n", fullpath);
fullpath_slash = strrchr(fullpath, '/');
while (true) {
if (!pack_fgets(buf, sizeof buf, f))
break;
filename = uconvert_toascii(buf, buf2);
strip(filename);
if ((filename[0] == '#') || (strlen(filename) == 0))
continue;
if (!fullpath_slash) {
snprintf(fullpath, sizeof fullpath, filename);
fullpath[(sizeof fullpath) - 1] = 0;
}
else {
snprintf(fullpath_slash+1, (sizeof fullpath) - (fullpath_slash - fullpath) - 1, filename);
fullpath[(sizeof fullpath) - 1] = 0;
}
if (!exists(uconvert_ascii(fullpath, buf)))
continue;
handle = dlopen(fullpath, RTLD_NOW);
if (!handle) {
/* useful during development */
/* printf("Error loading module: %s\n", dlerror()); */
continue;
}
init = dlsym(handle, "_module_init");
if (init)
init(system_driver);
m = al_malloc(sizeof(MODULE));
if (m) {
m->handle = handle;
m->next = module_list;
module_list = m;
}
}
pack_fclose(f);
}
/* main:
* Guess what this function does.
*/
int main(int argc, char *argv[])
{
PACKFILE *f;
CFURLRef cf_url_ref;
FSRef fs_ref;
FSSpec fs_spec;
IconFamilyHandle icon_family;
Handle raw_data;
char datafile[MAX_STRING_SIZE];
char bundle[MAX_STRING_SIZE];
char bundle_dir[MAX_STRING_SIZE];
char bundle_contents_dir[MAX_STRING_SIZE];
char bundle_contents_resources_dir[MAX_STRING_SIZE];
char bundle_contents_macos_dir[MAX_STRING_SIZE];
char bundle_contents_frameworks_dir[MAX_STRING_SIZE];
char *bundle_exe = NULL;
char bundle_plist[MAX_STRING_SIZE];
char bundle_pkginfo[MAX_STRING_SIZE];
char bundle_icns[MAX_STRING_SIZE];
char bundle_version[MAX_STRING_SIZE];
char bundle_long_version[MAX_STRING_SIZE];
char *buffer = NULL;
int arg, type = 0, result = 0;
int i, size, x, y, mask_bit, mask_byte;
unsigned char *data;
install_allegro(SYSTEM_NONE, &errno, &atexit);
set_color_depth(32);
set_color_conversion(COLORCONV_TOTAL | COLORCONV_KEEP_TRANS);
if (argc < 2)
usage();
datafile[0] = '\0';
bundle[0] = '\0';
select_palette(black_palette);
/* Parse command line and load any given resource */
for (arg = 2; arg < argc; arg++) {
if (!strcmp(argv[arg], "-m"))
flags |= F_MOVE;
else if (!strcmp(argv[arg], "-e"))
flags |= F_EMBED_FRAMEWORK;
else if (!strcmp(argv[arg], "-o")) {
if ((argc < arg + 2) || (bundle[0] != '\0'))
usage();
strcpy(bundle, argv[++arg]);
}
else if (!strcmp(argv[arg], "-v")) {
if (argc < arg + 2)
usage();
flags |= F_GOT_VERSION;
strcpy(bundle_version, argv[++arg]);
}
else if (!strcmp(argv[arg], "-V")) {
if (argc < arg + 2)
usage();
flags |= F_GOT_LONG_VERSION;
strcpy(bundle_long_version, argv[++arg]);
}
else if (!strcmp(argv[arg], "-d")) {
if (argc < arg + 2)
usage();
strcpy(datafile, argv[++arg]);
}
else if ((!strcmp(argv[arg], "-16")) || (!strcmp(argv[arg], "-32")) ||
(!strcmp(argv[arg], "-48")) || (!strcmp(argv[arg], "-128"))) {
if (argc < arg + 2)
usage();
switch (atoi(&argv[arg][1])) {
case 16: type = 0; break;
case 32: type = 1; break;
case 48: type = 2; break;
case 128: type = 3; break;
}
if (load_resource(datafile, argv[++arg], &icon_data[type])) {
result = -1;
goto exit_error;
}
}
else {
if (load_resource(datafile, argv[arg], NULL)) {
result = -1;
goto exit_error;
}
}
}
buffer = malloc(4096);
if (!buffer) {
result = -1;
goto exit_error_bundle;
}
bundle_exe = argv[1];
if (!exists(bundle_exe)) {
fprintf(stderr, "Cannot locate executable file '%s'\n", bundle_exe);
result = -1;
goto exit_error;
}
if (bundle[0] == '\0')
strcpy(bundle, bundle_exe);
replace_extension(bundle_dir, bundle, "app", MAX_STRING_SIZE);
strcpy(bundle_contents_dir, bundle_dir);
strcat(bundle_contents_dir, "/Contents");
strcpy(bundle_contents_resources_dir, bundle_contents_dir);
strcat(bundle_contents_resources_dir, "/Resources");
strcpy(bundle_contents_macos_dir, bundle_contents_dir);
strcat(bundle_contents_macos_dir, "/MacOS");
strcpy(bundle_contents_frameworks_dir, bundle_contents_dir);
strcat(bundle_contents_frameworks_dir, "/Frameworks");
bundle_icns[0] = '\0';
bundle_plist[0] = '\0';
bundle_pkginfo[0] = '\0';
/* Create bundle structure */
if ((mkdir(bundle_dir, 0777) && (errno != EEXIST)) ||
(mkdir(bundle_contents_dir, 0777) && (errno != EEXIST)) ||
(mkdir(bundle_contents_resources_dir, 0777) && (errno != EEXIST)) ||
(mkdir(bundle_contents_macos_dir, 0777) && (errno != EEXIST))) {
fprintf(stderr, "Cannot create %s\n", bundle_dir);
result = -1;
goto exit_error_bundle;
}
/* Copy/move executable into the bundle */
if (copy_file(bundle_exe, bundle_contents_macos_dir)) {
fprintf(stderr, "Cannot create %s\n", bundle_contents_macos_dir);
result = -1;
goto exit_error_bundle;
}
strcat(bundle_contents_macos_dir, "/");
strcat(bundle_contents_macos_dir, get_filename(bundle_exe));
chmod(bundle_contents_macos_dir, 0755);
if (flags & F_MOVE)
unlink(bundle_exe);
/* Embed Allegro framework if requested */
if (flags & F_EMBED_FRAMEWORK) {
if (!file_exists("/Library/Frameworks/Allegro.framework", FA_RDONLY | FA_DIREC, NULL)) {
fprintf(stderr, "Cannot find Allegro framework\n");
result = -1;
goto exit_error_bundle;
}
if (!exists("/Library/Frameworks/Allegro.framework/Resources/Embeddable")) {
fprintf(stderr, "Cannot embed system wide Allegro framework; install embeddable version first!\n");
result = -1;
goto exit_error_bundle;
}
sprintf(buffer, "/Developer/Tools/pbxcp -exclude .DS_Store -exclude CVS -resolve-src-symlinks /Library/Frameworks/Allegro.framework %s", bundle_contents_frameworks_dir);
if ((mkdir(bundle_contents_frameworks_dir, 0777) && (errno != EEXIST)) ||
(system(buffer))) {
fprintf(stderr, "Cannot create %s\n", bundle_contents_frameworks_dir);
result = -1;
goto exit_error_bundle;
}
}
/* Setup the .icns resource */
if (flags & F_ICONS_DEFINED) {
strcat(bundle_contents_resources_dir, "/");
strcat(bundle_contents_resources_dir, get_filename(bundle));
replace_extension(bundle_icns, bundle_contents_resources_dir, "icns", MAX_STRING_SIZE);
icon_family = (IconFamilyHandle)NewHandle(0);
for (i = 0; i < 4; i++) {
if (flags & icon_data[i].defined) {
/* Set 32bit RGBA data */
raw_data = NewHandle(icon_data[i].size * icon_data[i].size * 4);
data = *(unsigned char **)raw_data;
for (y = 0; y < icon_data[i].size; y++) {
for (x = 0; x < icon_data[i].size; x++) {
*data++ = geta32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
*data++ = getr32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
*data++ = getg32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
*data++ = getb32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
}
}
if (SetIconFamilyData(icon_family, icon_data[i].data, raw_data) != noErr) {
DisposeHandle(raw_data);
fprintf(stderr, "Error setting %dx%d icon resource RGBA data\n", icon_data[i].size, icon_data[i].size);
result = -1;
goto exit_error_bundle;
}
DisposeHandle(raw_data);
/* Set 8bit mask */
raw_data = NewHandle(icon_data[i].size * icon_data[i].size);
data = *(unsigned char **)raw_data;
for (y = 0; y < icon_data[i].size; y++) {
for (x = 0; x < icon_data[i].size; x++) {
*data++ = geta32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
}
}
if (SetIconFamilyData(icon_family, icon_data[i].mask8, raw_data) != noErr) {
DisposeHandle(raw_data);
fprintf(stderr, "Error setting %dx%d icon resource 8bit mask\n", icon_data[i].size, icon_data[i].size);
result = -1;
goto exit_error_bundle;
}
DisposeHandle(raw_data);
/* Set 1bit mask */
if (icon_data[i].mask1) {
size = ((icon_data[i].size * icon_data[i].size) + 7) / 8;
raw_data = NewHandle(size * 2);
data = *(unsigned char **)raw_data;
mask_byte = 0;
mask_bit = 7;
for (y = 0; y < icon_data[i].size; y++) {
for (x = 0; x < icon_data[i].size; x++) {
if (geta32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]) >= 0xfd)
mask_byte |= (1 << mask_bit);
mask_bit--;
if (mask_bit < 0) {
*data++ = mask_byte;
mask_byte = 0;
mask_bit = 7;
}
}
}
memcpy(*raw_data + size, *raw_data, size);
if (SetIconFamilyData(icon_family, icon_data[i].mask1, raw_data) != noErr) {
DisposeHandle(raw_data);
fprintf(stderr, "Error setting %dx%d icon resource 1bit mask\n", icon_data[i].size, icon_data[i].size);
result = -1;
goto exit_error_bundle;
}
DisposeHandle(raw_data);
}
}
}
f = pack_fopen(bundle_icns, F_WRITE);
if (!f) {
fprintf(stderr, "Cannot create %s\n", bundle_icns);
result = -1;
goto exit_error_bundle;
}
pack_fclose(f);
cf_url_ref = CFURLCreateWithBytes(kCFAllocatorDefault, (unsigned char *)bundle_icns, strlen(bundle_icns), 0, NULL);
if (!cf_url_ref) {
fprintf(stderr, "Cannot create %s\n", bundle_icns);
result = -1;
goto exit_error_bundle;
}
CFURLGetFSRef(cf_url_ref, &fs_ref);
CFRelease(cf_url_ref);
if ((FSGetCatalogInfo(&fs_ref, kFSCatInfoNone, NULL, NULL, &fs_spec, NULL)) ||
(WriteIconFile(icon_family, &fs_spec) != noErr)) {
fprintf(stderr, "Cannot create %s\n", bundle_icns);
result = -1;
goto exit_error_bundle;
}
DisposeHandle((Handle)icon_family);
}
/* Setup Info.plist */
sprintf(bundle_plist, "%s/Info.plist", bundle_contents_dir);
f = pack_fopen(bundle_plist, F_WRITE);
if (!f) {
fprintf(stderr, "Cannot create %s\n", bundle_plist);
result = -1;
goto exit_error_bundle;
}
sprintf(buffer, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
"<plist version=\"1.0\">\n"
"<dict>\n"
"\t<key>CFBundleExecutable</key>\n"
"\t<string>%s</string>\n"
"\t<key>CFBundleInfoDictionaryVersion</key>\n"
"\t<string>6.0</string>\n"
"\t<key>CFBundlePackageType</key>\n"
"\t<string>APPL</string>\n"
"\t<key>CFBundleSignature</key>\n"
"\t<string>%s</string>\n"
"\t<key>CFBundleVersion</key>\n"
"\t<string>%s</string>\n"
"\t<key>CFBundleDocumentTypes</key>\n"
"\t<array>\n"
"\t\t<dict>\n"
"\t\t\t<key>CFBundleTypeExtensions</key>\n"
"\t\t\t<array>\n"
"\t\t\t\t<string>*</string>\n"
"\t\t\t</array>\n"
"\t\t\t<key>CFBundleTypeName</key>\n"
"\t\t\t<string>NSStringPboardType</string>\n"
"\t\t\t<key>CFBundleTypeOSTypes</key>\n"
"\t\t\t<array>\n"
"\t\t\t\t<string>****</string>\n"
"\t\t\t</array>\n"
"\t\t\t<key>CFBundleTypeRole</key>\n"
"\t\t\t<string>Viewer</string>\n"
"\t\t</dict>\n"
"\t</array>\n",
get_filename(bundle_exe), "????", (flags & F_GOT_VERSION) ? bundle_version : "1.0");
pack_fputs(buffer, f);
if (flags & F_GOT_LONG_VERSION) {
sprintf(buffer, "\t<key>CFBundleGetInfoString</key>\n"
"\t<string>%s</string>\n", bundle_long_version);
pack_fputs(buffer, f);
}
if (flags & F_ICONS_DEFINED) {
sprintf(buffer, "\t<key>CFBundleIconFile</key>\n"
"\t<string>%s</string>\n", get_filename(bundle_icns));
pack_fputs(buffer, f);
}
pack_fputs("</dict>\n</plist>\n", f);
pack_fclose(f);
/* Setup PkgInfo */
sprintf(bundle_pkginfo, "%s/PkgInfo", bundle_contents_dir);
f = pack_fopen(bundle_pkginfo, F_WRITE);
if (!f) {
fprintf(stderr, "Cannot create %s\n", bundle_pkginfo);
result = -1;
goto exit_error_bundle;
}
pack_fputs("APPL????", f);
pack_fclose(f);
exit_error:
if (buffer)
free(buffer);
for (i = 0; i < 4; i++) {
if (icon_data[i].original)
destroy_bitmap(icon_data[i].original);
if (icon_data[i].workspace)
destroy_bitmap(icon_data[i].workspace);
if (icon_data[i].scaled)
destroy_bitmap(icon_data[i].scaled);
}
return result;
exit_error_bundle:
sprintf(buffer, "%s/%s", bundle_contents_macos_dir, get_filename(bundle_exe));
unlink(buffer);
unlink(bundle_plist);
unlink(bundle_pkginfo);
unlink(bundle_icns);
rmdir(bundle_dir);
rmdir(bundle_contents_dir);
rmdir(bundle_contents_resources_dir);
rmdir(bundle_contents_macos_dir);
goto exit_error;
}
int eof_export_bandfuse(EOF_SONG * sp, char * fn, unsigned short *user_warned)
{
PACKFILE * fp;
char buffer[600] = {0}, buffer2[600] = {0};
EOF_PRO_GUITAR_TRACK *tp;
char restore_tech_view = 0; //If tech view is in effect, it is temporarily disabled so that the correct notes are exported
unsigned long ctr, ctr2, ctr3, ctr4, ctr5, gemcount, bitmask, guitartracknum = 0, basstracknum = 0;
eof_log("eof_export_bandfuse() entered", 1);
if(!sp || !fn || !sp->beats || !user_warned)
{
eof_log("\tError saving: Invalid parameters", 1);
return 0; //Return failure
}
fp = pack_fopen(fn, "w");
if(!fp)
{
eof_log("\tError saving: Cannot open file for writing", 1);
return 0; //Return failure
}
//Write the song metadata
(void) pack_fputs("<?xml version='1.0' encoding='UTF-8'?>\n", fp);
(void) pack_fputs("<Bandfuse>\n", fp);
(void) pack_fputs("<!-- " EOF_VERSION_STRING " -->\n", fp); //Write EOF's version in an XML comment
expand_xml_text(buffer2, sizeof(buffer2) - 1, sp->tags->title, 64, 0); //Expand XML special characters into escaped sequences if necessary, and check against the maximum supported length of this field
(void) snprintf(buffer, sizeof(buffer) - 1, " <title>%s</title>\n", buffer2);
(void) pack_fputs(buffer, fp);
expand_xml_text(buffer2, sizeof(buffer2) - 1, sp->tags->artist, 256, 0); //Replace any special characters in the artist song property with escape sequences if necessary
(void) snprintf(buffer, sizeof(buffer) - 1, " <artistName>%s</artistName>\n", buffer2);
(void) pack_fputs(buffer, fp);
expand_xml_text(buffer2, sizeof(buffer2) - 1, sp->tags->album, 256, 0); //Replace any special characters in the album song property with escape sequences if necessary
(void) snprintf(buffer, sizeof(buffer) - 1, " <albumName>%s</albumName>\n", buffer2);
(void) pack_fputs(buffer, fp);
expand_xml_text(buffer2, sizeof(buffer2) - 1, sp->tags->year, 32, 0); //Replace any special characters in the year song property with escape sequences if necessary
(void) snprintf(buffer, sizeof(buffer) - 1, " <albumYear>%s</albumYear>\n", buffer2);
(void) pack_fputs(buffer, fp);
//Write tempo changes
(void) pack_fputs(" <tempochanges>\n", fp);
ctr = 0; //Begin with the first beat
while(ctr < sp->beats)
{ //Until the last beat has been reached
for(ctr2 = ctr + 1; ctr2 < sp->beats; ctr2++)
{ //For each beat that follows
if(sp->beat[ctr]->ppqn != sp->beat[ctr2]->ppqn)
{ //If the following beat has a different tempo
break; //Break from inner for loop
}
}
if(ctr2 < sp->beats)
{ //If a beat with a different tempo was found, that beat is written as the end position of this tempo change
(void) snprintf(buffer, sizeof(buffer) - 1, " <tempo start=\"%lu\" end=\"%lu\" tempo=\"%f\">\n", sp->beat[ctr]->pos, sp->beat[ctr2]->pos, 60000000.0 / (double)sp->beat[ctr]->ppqn);
}
else
{ //No remaining beats had a different tempo, the outer for loop's beat is written as the end position of this tempo change
(void) snprintf(buffer, sizeof(buffer) - 1, " <tempo start=\"%lu\" end=\"%lu\" tempo=\"%f\">\n", sp->beat[ctr]->pos, sp->beat[ctr]->pos, 60000000.0 / (double)sp->beat[ctr]->ppqn);
}
(void) pack_fputs(buffer, fp);
ctr = ctr2; //Advance the beat counter
}
(void) pack_fputs(" </tempochanges>\n", fp);
for(ctr = 1; ctr < sp->tracks; ctr++)
{ //For each track
if(ctr >= EOF_TRACKS_MAX)
break; //Redundant bounds check to satisfy a false positive with Coverity
if(sp->track[ctr]->track_format != EOF_PRO_GUITAR_TRACK_FORMAT)
continue; //If this isn't a pro guitar/bass track, skip it
if(ctr == EOF_TRACK_PRO_GUITAR_B)
continue; //If this is the bonus Rocksmith arrangement, skip it
tp = sp->pro_guitar_track[sp->track[ctr]->tracknum];
restore_tech_view = eof_menu_track_get_tech_view_state(sp, ctr);
eof_menu_track_set_tech_view_state(sp, ctr, 0); //Disable tech view if applicable
if(tp->notes)
{ //If this track is populated
eof_determine_phrase_status(sp, ctr); //Update the trill and tremolo status of each note
if(tp->arrangement != 4)
{ //If this isn't a bass track
guitartracknum++; //Keep count of how many of this track type there have been
(void) snprintf(buffer, sizeof(buffer) - 1, " <arrangement name=\"Guitar %lu (%s)\">\n", guitartracknum, sp->track[ctr]->name);
(void) pack_fputs(buffer, fp);
}
else
{ //This is a bass track
basstracknum++; //Keep count of how many of this track type there have been
(void) snprintf(buffer, sizeof(buffer) - 1, " <arrangement name=\"Bass %lu (%s)\">\n", guitartracknum, sp->track[ctr]->name);
(void) pack_fputs(buffer, fp);
}
(void) snprintf(buffer, sizeof(buffer) - 1, " <tuning string0=\"%d\" string1=\"%d\" string2=\"%d\" string3=\"%d\" string4=\"%d\" string5=\"%d\" />\n", tp->tuning[0], tp->tuning[1], tp->tuning[2], tp->tuning[3], tp->tuning[4], tp->tuning[5]);
(void) pack_fputs(buffer, fp);
(void) eof_detect_difficulties(sp, ctr); //Update eof_track_diff_populated_status[] to reflect all populated difficulties for this track
for(ctr2 = 0; ctr2 < 6; ctr2++)
{ //For each of the first 6 difficulties
unsigned long anchorcount;
char anchorsgenerated = 0; //Is set to nonzero if fret hand positions are automatically generated for this difficulty and will have to be deleted
if(!eof_track_diff_populated_status[ctr2])
continue; //If this difficulty is not populated, skip it
(void) snprintf(buffer, sizeof(buffer) - 1, " <level difficulty=\"%lu\">\n", ctr2);
(void) pack_fputs(buffer, fp);
//Count the number of note gems in this track difficulty
for(ctr3 = 0, gemcount = 0; ctr3 < tp->notes; ctr3++)
{ //For each note in the track
if(eof_get_note_type(sp, ctr, ctr3) == ctr2)
{ //If the note is in this difficulty
gemcount += eof_note_count_rs_lanes(sp, ctr, ctr3, 2); //Add this note's number of non-ghosted gems to a counter
}
}
(void) snprintf(buffer, sizeof(buffer) - 1, " <notes count=\"%lu\">\n", gemcount);
(void) pack_fputs(buffer, fp);
//Generate fret hand positions if there are none for this difficulty
for(ctr3 = 0, anchorcount = 0; ctr3 < tp->handpositions; ctr3++)
{ //For each hand position defined in the track
if(tp->handposition[ctr3].difficulty == ctr2)
{ //If the hand position is in this difficulty
anchorcount++;
}
}
if(!anchorcount)
{ //If there are no anchors in this track difficulty, automatically generate them
if((tp->arrangement != 4) || eof_warn_missing_bass_fhps)
{ //Don't warn about missing FHPs in bass arrangements if user disabled that preference
if((*user_warned & 1) == 0)
{ //If the user wasn't alerted that one or more track difficulties have no fret hand positions defined
allegro_message("Warning: At least one track difficulty has no fret hand positions defined. They will be created automatically.");
*user_warned |= 1;
}
}
eof_fret_hand_position_list_dialog_undo_made = 1; //Ensure no undo state is written during export
eof_generate_efficient_hand_positions(sp, ctr, ctr2, 0, 0); //Generate the fret hand positions for the track difficulty being currently written
anchorsgenerated = 1;
}
for(ctr3 = 0, anchorcount = 0; ctr3 < tp->handpositions; ctr3++) //Re-count the hand positions
{ //For each hand position defined in the track
if(tp->handposition[ctr3].difficulty == ctr)
{ //If the hand position is in this difficulty
anchorcount++;
}
}
//Write the notes to XML
for(ctr3 = 0; ctr3 < tp->notes; ctr3++)
{ //For each note in the track
if(eof_get_note_type(sp, ctr, ctr3) != ctr2)
continue; //If the note is not in this difficulty, skip it
for(ctr4 = 0, bitmask = 1; ctr4 < tp->numstrings; ctr4++, bitmask <<= 1)
{ //For each string in this track
EOF_RS_TECHNIQUES tech = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned long notepos;
unsigned long fret, finger; //The fret and finger numbers used to play the gem on this string
unsigned long trill_start, trill_stop; //The start and stop positions of the note's trill phrase
int trillwith = -1; //If the note is in a trill phrase, this is set to the fret value of the next or previous gem on the string
long next;
unsigned long stringnum; //The converted string number (ie. low E string is string 6)
char *sustainpadding;
if(!(tp->note[ctr3]->note & bitmask) || (tp->note[ctr3]->ghost & bitmask))
continue; //If this string does not have a gem, or if it has one that is ghosted, skip it
trill_start = trill_stop = tp->note[ctr3]->pos; //Initialize variables in order to track if the trill phrase can't be properly found
if(tp->note[ctr3]->flags & EOF_NOTE_FLAG_IS_TRILL)
{ //If this note is in a trill phrase
//Find which trill phrase it's in
for(ctr5 = 0; ctr5 < tp->trills; ctr5++)
{ //For each trill phrase
if((tp->trill[ctr5].difficulty == 0xFF) || (tp->trill[ctr5].difficulty == ctr2))
{ //If this trill phrase applies to all difficulties or if it otherwise applies to this note's difficulty
if((tp->trill[ctr5].start_pos <= tp->note[ctr3]->pos) && (tp->trill[ctr5].end_pos >= tp->note[ctr3]->pos))
{ //If the note is inside this trill phrase
trill_start = tp->trill[ctr5].start_pos;
trill_stop = tp->trill[ctr5].end_pos;
break;
}
}
}
//Determine if this is the first note in the trill phrase, and if so, what note it trills with
if(trill_start != trill_stop)
{ //If a trill phrase was identified
for(ctr5 = 0; ctr5 < tp->notes; ctr5++)
{ //For each note in the track
if(eof_get_note_type(sp, ctr, ctr3) != ctr2)
continue; //If the note is not in this difficulty, skip it
if(tp->note[ctr5]->pos > trill_stop)
break; //Stop looking at notes if the trill has already been passed
if(tp->note[ctr5]->pos < trill_start)
continue; //If the note is not within the trill phrase
if(ctr5 != ctr3)
{ //If the note being written to XML is not this note
break; //Don't export it with trill technique
}
next = eof_fixup_next_pro_guitar_note(tp, ctr5);
if((next > 0) && (tp->note[next]->pos <= trill_stop))
{ //If the next note in the track difficulty is also in this trill phrase
if((tp->note[next]->note & bitmask) && ((tp->note[next]->frets[next] & 0x7F) > (tp->note[ctr3]->frets[ctr4] & 0x7F)))
{ //If the next note has a gem on the target string and its fret value is higher than that of the note being currently written to XML
trillwith = tp->note[next]->frets[ctr4] & 0x7F; //This is the fret value being trilled with
}
}
break;
}//For each note in the track
}//If a trill phrase was identified
}//If this note is in a trill phrase
(void) eof_get_rs_techniques(sp, ctr, ctr3, ctr4, &tech, 2, 1); //Determine techniques used by this note (honoring technotes where applicable)
notepos = eof_get_note_pos(sp, ctr, ctr3);
fret = tp->note[ctr3]->frets[ctr4] & 0x7F; //Get the fret value for this string (mask out the muting bit)
finger = eof_pro_guitar_note_lookup_string_fingering(tp, ctr3, ctr4, 1); //Unless a more suitable fingering for this note can be determined, assume 1 (index)
if(tech.length < 10)
{ //The sustain is one digit
sustainpadding = " ";
}
else if(tech.length < 100)
{ //The sustain is two digits
sustainpadding = " ";
}
else if(tech.length < 1000)
{ //The sustain is three digits
sustainpadding = " ";
}
else
{ //It's four or more digits
sustainpadding = "";
}
fret += tp->capo; //Compensate for the the capo position if applicable
stringnum = tp->numstrings - ctr4; //Convert to tab string numbering (low E is string 6 in a 6 string track, string 4 on a 4 string track, etc)
(void) snprintf(buffer, sizeof(buffer) - 1, " <note time=\"%lu\" linkNext=\"%d\" bend=\"%lu\" fret=%s\"%lu\" hammerOn=\"%d\" harmonic=\"%d\" hopo=\"%d\" ignore=\"0\" mute=\"%d\" palmMute=\"%d\" pluck=\"%d\" pullOff=\"%d\" slap=\"%d\" slideTo=\"%ld\" string=\"%lu\" sustain=%s\"%lu\" tremolo=\"%d\" harmonicPinch=\"%d\" slideUnpitchTo=\"%ld\" trillwith=\"%d\" finger=\"%lu\" vibrato=\"%d\"/>\n", notepos, tech.linknext, tech.bendstrength_h, ((fret < 10) ? " " : ""), fret, tech.hammeron, tech.harmonic, tech.hopo, tech.stringmute, tech.palmmute, tech.pop, tech.pulloff, tech.slap, tech.slideto, stringnum, sustainpadding, tech.length, tech.tremolo, tech.pinchharmonic, tech.unpitchedslideto, trillwith, finger, tech.vibrato);
(void) pack_fputs(buffer, fp);
}//For each string in this track
}//For each note in the track
//Remove any automatically generated fret hand positions
if(anchorsgenerated)
{ //If anchors were automatically generated for this track difficulty, remove them now
for(ctr3 = tp->handpositions; ctr3 > 0; ctr3--)
{ //For each hand position defined in the track, in reverse order
if(tp->handposition[ctr3 - 1].difficulty == ctr2)
{ //If the hand position is in this difficulty
eof_pro_guitar_track_delete_hand_position(tp, ctr3 - 1); //Delete the hand position
}
}
}
(void) pack_fputs(" </notes>\n", fp);
(void) pack_fputs(" </level>\n", fp);
}//For each of the first 6 difficulties
(void) pack_fputs(" </arrangement>\n", fp);
}//If this track is populated
eof_menu_track_set_tech_view_state(sp, ctr, restore_tech_view); //Re-enable tech view if applicable
}//For each track
(void) pack_fputs("</Bandfuse>\n", fp);
//Cleanup
(void) pack_fclose(fp);
return 1; //Return success
}
/* load_txt_font:
* Loads a scripted font.
*/
FONT *load_txt_font(AL_CONST char *filename, RGB *pal, void *param)
{
char buf[1024], *font_str, *start_str = 0, *end_str = 0;
char font_filename[1024];
FONT *f, *f2, *f3, *f4;
PACKFILE *pack;
int begin, end, glyph_pos=32;
pack = pack_fopen(filename, F_READ);
if (!pack)
return NULL;
f = f2 = f3 = f4 = NULL;
while(pack_fgets(buf, sizeof(buf)-1, pack)) {
font_str = strtok(buf, " \t");
if (font_str)
start_str = strtok(0, " \t");
if (start_str)
end_str = strtok(0, " \t");
if (!font_str || !start_str) {
if (f)
destroy_font(f);
if (f2)
destroy_font(f2);
pack_fclose(pack);
return NULL;
}
if(font_str[0] == '-')
font_str[0] = '\0';
begin = strtol(start_str, 0, 0);
if (end_str)
end = strtol(end_str, 0, 0);
else
end = -1;
if(begin <= 0 || (end > 0 && end < begin)) {
if (f)
destroy_font(f);
if (f2)
destroy_font(f2);
pack_fclose(pack);
return NULL;
}
/* Load the font that needs to be merged with the current font */
if (font_str[0]) {
if (f2)
destroy_font(f2);
if (exists(font_str)) {
f2 = load_font(font_str, pal, param);
} else if (is_relative_filename(font_str)) {
replace_filename(font_filename, filename, font_str,
sizeof(font_filename));
f2 = load_font(font_filename, pal, param);
}
else {
f2 = NULL;
}
if (f2)
glyph_pos=get_font_range_begin(f2, -1);
}
if (!f2) {
if (f)
destroy_font(f);
pack_fclose(pack);
return NULL;
}
if (end == -1)
end = begin + get_font_range_end(f2,-1) - glyph_pos;
/* transpose the font to the range given in the .txt file */
f4=extract_font_range(f2,glyph_pos,glyph_pos + (end - begin));
if (f4 && (begin != glyph_pos)) {
transpose_font(f4, begin - glyph_pos);
}
glyph_pos += (end - begin) + 1;
/* FIXME: More efficient way than to repeatedely merge into a new font? */
if (f && f4) {
f3 = f;
f = merge_fonts(f4, f3);
destroy_font(f4);
destroy_font(f3);
}
else {
f = f4;
}
f3=f4=NULL;
}
if (f2)
destroy_font(f2);
pack_fclose(pack);
return f;
}
/*
* Compresses all the frames in the animation and writes to a gif file.
* Nothing else like extensions or comments is written.
*
* Returns 0 on success.
*
* Note: All bitmaps must have a color depth of 8.
*/
int
algif_save_raw_animation (const char *filename, GIF_ANIMATION *gif)
{
int frame;
int i, j;
PACKFILE *file;
file = pack_fopen (filename, "w");
if (!file)
return -1;
pack_fwrite ("GIF89a", 6, file);
pack_iputw (gif->width, file);
pack_iputw (gif->height, file);
/* 7 global palette
* 456 color richness
* 3 sorted
* 012 palette bits
*/
for (i = 1, j = 0; i < gif->palette.colors_count; i *= 2, j++);
pack_putc ((j ? 128 : 0) + 64 + 32 + 16 + (j ? j - 1 : 0), file);
pack_putc (gif->background_index, file);
pack_putc (0, file); /* No aspect ratio. */
if (j)
write_palette (file, &gif->palette, j);
if (gif->loop != -1)
/* Loop count extension. */
{
pack_putc (0x21, file); /* Extension Introducer. */
pack_putc (0xff, file); /* Application Extension. */
pack_putc (11, file); /* Size. */
pack_fwrite ("NETSCAPE2.0", 11, file);
pack_putc (3, file); /* Size. */
pack_putc (1, file);
pack_iputw (gif->loop, file);
pack_putc (0, file);
}
for (frame = 0; frame < gif->frames_count; frame++)
{
int w = gif->frames[frame].bitmap_8_bit->w;
int h = gif->frames[frame].bitmap_8_bit->h;
pack_putc (0x21, file); /* Extension Introducer. */
pack_putc (0xf9, file); /* Graphic Control Extension. */
pack_putc (4, file); /* Size. */
/* Disposal method, and enable transparency. */
i = gif->frames[frame].disposal_method << 2;
if (gif->frames[frame].transparent_index != -1)
i |= 1;
pack_putc (i, file);
pack_iputw (gif->frames[frame].duration, file); /* In 1/100th seconds. */
if (gif->frames[frame].transparent_index != -1)
pack_putc (gif->frames[frame].transparent_index, file); /* Transparent color index. */
else
pack_putc (0, file);
pack_putc (0x00, file); /* Terminator. */
pack_putc (0x2c, file); /* Image Descriptor. */
pack_iputw (gif->frames[frame].xoff, file);
pack_iputw (gif->frames[frame].yoff, file);
pack_iputw (w, file);
pack_iputw (h, file);
/* 7: local palette
* 6: interlaced
* 5: sorted
* 012: palette bits
*/
for (i = 1, j = 0; i < gif->frames[frame].palette.colors_count; i *= 2, j++);
pack_putc ((j ? 128 : 0) + (j ? j - 1 : 0), file);
if (j)
write_palette (file, &gif->frames[frame].palette, j);
LZW_encode (file, gif->frames[frame].bitmap_8_bit);
pack_putc (0x00, file); /* Terminator. */
}
pack_putc (0x3b, file); /* Trailer. */
pack_fclose (file);
return 0;
}
int main (int argc, char *argv[])
{
FILE *in;
int i;
char buffer[128];
char *outfilename;
PACKFILE *fout;
enum
{
UNKNOWN,
PLAYER,
MONSTER,
TILESET
} type;
allegro_init ();
if (argc == 1) {
/* No files to process */
fprintf (stdout, "# Default value dump by %s\nplayer\n", argv[0]);
for (i = 0; i < MAXCHRS; ++i)
save_s_player_txt (&default_players[i], stdout);
fprintf (stdout, "# Default value dump by %s\ntileset\n", argv[0]);
for (i = 0; i < MAX_TILESETS; ++i) {
save_s_tileset_txt (&default_tilesets[i], stdout);
}
return 0;
}
while (--argc) {
in = fopen (argv[argc], "r");
if (in) {
/* Decide what kind of file */
while (1) {
type = UNKNOWN;
if (fgets (buffer, sizeof (buffer), in) == NULL) {
break;
}
if (buffer[0] != '#' && buffer[0] != '\n') {
if (strncmp (buffer, "player", 6) == 0) {
type = PLAYER;
}
if (strncmp (buffer, "monster", 7) == 0) {
type = MONSTER;
}
if (strncmp (buffer, "tileset", 7) == 0) {
type = TILESET;
}
break;
}
}
switch (type) {
case PLAYER:
fout = pack_fopen ("../data/hero.kq", F_WRITE_PACKED);
process_plr (in, fout);
pack_fclose (fout);
break;
case TILESET:
fout = pack_fopen ("../data/tileset.kq", F_WRITE_PACKED);
process_ts (in, fout);
pack_fclose (fout);
break;
default:
outfilename = NULL;
fprintf (stderr, "Unknown file type %s\n", buffer);
break;
}
fclose (in);
} else {
fprintf (stderr, "Could not open '%s' for reading\n", argv[argc]);
return 1;
}
}
return 0;
} END_OF_MAIN ()
/* loads a MSK file (Animator and Animator Pro format) */
Mask *load_msk_file(const char *filename)
{
#if (MAKE_VERSION(4, 2, 1) >= MAKE_VERSION(ALLEGRO_VERSION, \
ALLEGRO_SUB_VERSION, \
ALLEGRO_WIP_VERSION))
int orig_size = file_size(filename);
#else
int orig_size = file_size_ex(filename);
#endif
int i, c, u, v, byte, magic, size;
Mask *mask = NULL;
PACKFILE *f;
f = pack_fopen(filename, F_READ);
if (!f)
return NULL;
size = pack_igetl(f);
magic = pack_igetw(f);
/* Animator Pro MSK format */
if ((size == orig_size) && (magic == 0x9500)) {
Image *image;
int x, y;
pack_fclose(f);
/* just load an Animator Pro PIC file */
image = load_pic_file(filename, &x, &y, NULL);
if ((!image) || (image->imgtype != IMAGE_BITMAP)) {
if (image)
image_free(image);
}
else {
mask = mask_new();
mask->x = x;
mask->y = y;
mask->w = image->w;
mask->h = image->h;
mask->bitmap = image;
}
}
/* Animator MSK format */
else if (orig_size == 8000) {
mask = mask_new();
mask_replace(mask, 0, 0, 320, 200);
u = v = 0;
for (i=0; i<8000; i++) {
byte = pack_getc (f);
for (c=0; c<8; c++) {
mask->bitmap->putpixel(u, v, byte & (1<<(7-c)));
u++;
if (u == 320) {
u = 0;
v++;
}
}
}
pack_fclose(f);
}
else {
pack_fclose(f);
}
return mask;
}
static void *dumb_packfile_open(const char *filename)
{
return pack_fopen(filename, F_READ);
}
int eof_undo_add(int type)
{
char fn[1024] = {0}, temp[1024] = {0};
unsigned long ctr;
eof_log("eof_undo_add() entered", 1);
if(eof_undo_states_initialized == -1)
{ //The undo filename array couldn't be initialized previously
return 0;
}
if(eof_validate_temp_folder())
{ //Ensure the correct working directory and presence of the temporary folder
eof_log("\tCould not validate working directory and temp folder", 1);
return 0;
}
if(!eof_undo_states_initialized)
{ //Initialize the undo filename array
for(ctr = 0; ctr < EOF_MAX_UNDO; ctr++)
{ //For each undo slot
(void) snprintf(fn, sizeof(fn) - 1, "%seof%03u-%03lu.undo", eof_temp_path_s, eof_log_id, ctr); //Build the undo filename in the format of "eof#-#.undo", where the first number is the EOF ID
eof_undo_filename[ctr] = malloc(sizeof(fn) + 1);
if(eof_undo_filename[ctr] == NULL)
{
allegro_message("Error initializing undo system. Undo disabled");
eof_undo_states_initialized = -1;
return 0;
}
strcpy(eof_undo_filename[ctr], fn); //Save the undo filename to the array
}
eof_undo_states_initialized = 1;
}
if((type == EOF_UNDO_TYPE_NOTE_LENGTH) && (eof_undo_last_type == EOF_UNDO_TYPE_NOTE_LENGTH))
{
return 0;
}
if((type == EOF_UNDO_TYPE_LYRIC_NOTE) && (eof_undo_last_type == EOF_UNDO_TYPE_LYRIC_NOTE))
{
return 0;
}
if((type == EOF_UNDO_TYPE_RECORD) && (eof_undo_last_type == EOF_UNDO_TYPE_RECORD))
{
return 0;
}
if((type == EOF_UNDO_TYPE_TEMPO_ADJUST) && (eof_undo_last_type == EOF_UNDO_TYPE_TEMPO_ADJUST))
{
return 0;
}
if(type == EOF_UNDO_TYPE_SILENCE)
{
(void) snprintf(fn, sizeof(fn) - 1, "%s%s.ogg", eof_temp_path_s, eof_undo_filename[eof_undo_current_index]);
(void) eof_copy_file(eof_loaded_ogg_name, fn);
}
eof_undo_last_type = type;
(void) eof_save_song(eof_song, eof_undo_filename[eof_undo_current_index]);
eof_undo_type[eof_undo_current_index] = type;
if(eof_recovery)
{ //If this EOF instance is maintaining auto-recovery files
PACKFILE *fp;
(void) snprintf(fn, sizeof(fn) - 1, "%seof.recover", eof_temp_path_s);
fp = pack_fopen(fn, "w"); //Open the recovery definition file for writing
if(fp)
{ //If the file opened
(void) append_filename(temp, eof_song_path, eof_loaded_song_name, 1024); //Construct the full path to the project file
(void) pack_fputs(eof_undo_filename[eof_undo_current_index], fp); //Write the undo file path
(void) pack_fputs("\n", fp); //Write a newline character
(void) pack_fputs(temp, fp); //Write the project path
(void) pack_fclose(fp);
}
}
eof_undo_current_index++;
if(eof_undo_current_index >= EOF_MAX_UNDO)
{
eof_undo_current_index = 0;
}
eof_undo_count++;
if(eof_undo_count >= EOF_MAX_UNDO)
{
eof_undo_count = EOF_MAX_UNDO;
}
eof_redo_count = 0;
return 1;
}
char* get_cached_sound(const char* filename, bool is_wave, long* size)
{
_sound_cache_mutex.Lock();
#ifdef SOUND_CACHE_DEBUG
printf("get_cached_sound(%s %d)\n", filename, (unsigned int)is_wave);
#endif
*size = 0;
int i;
for (i = 0; i < psp_audio_cachesize; i++)
{
if (sound_cache_entries[i].data == NULL)
continue;
if (strcmp(filename, sound_cache_entries[i].file_name) == 0)
{
#ifdef SOUND_CACHE_DEBUG
printf("..found in slot %d\n", i);
#endif
sound_cache_entries[i].reference++;
sound_cache_entries[i].last_used = sound_cache_counter++;
*size = sound_cache_entries[i].size;
_sound_cache_mutex.Unlock();
return sound_cache_entries[i].data;
}
}
// Not found
PACKFILE *mp3in = NULL;
SAMPLE* wave = NULL;
if (is_wave)
{
PACKFILE *wavin = pack_fopen(filename, "rb");
if (wavin != NULL)
{
wave = load_wav_pf(wavin);
pack_fclose(wavin);
}
}
else
{
mp3in = pack_fopen(filename, "rb");
if (mp3in == NULL)
{
_sound_cache_mutex.Unlock();
return NULL;
}
}
// Find free slot
for (i = 0; i < psp_audio_cachesize; i++)
{
if (sound_cache_entries[i].data == NULL)
break;
}
// No free slot?
if (i == psp_audio_cachesize)
{
unsigned int oldest = sound_cache_counter;
int index = -1;
for (i = 0; i < psp_audio_cachesize; i++)
{
if (sound_cache_entries[i].reference == 0)
{
if (sound_cache_entries[i].last_used < oldest)
{
oldest = sound_cache_entries[i].last_used;
index = i;
}
}
}
i = index;
}
// Load new file
char* newdata;
if (is_wave)
{
*size = 0;
newdata = (char*)wave;
}
else
{
*size = mp3in->todo;
newdata = (char *)malloc(*size);
if (newdata == NULL)
{
pack_fclose(mp3in);
_sound_cache_mutex.Unlock();
return NULL;
}
pack_fread(newdata, *size, mp3in);
pack_fclose(mp3in);
}
if (i == -1)
{
// No cache slot empty, return uncached data
#ifdef SOUND_CACHE_DEBUG
printf("..loading uncached\n");
#endif
_sound_cache_mutex.Unlock();
return newdata;
}
else
{
// Add to cache, free old sound first
#ifdef SOUND_CACHE_DEBUG
printf("..loading cached in slot %d\n", i);
#endif
if (sound_cache_entries[i].data) {
if (sound_cache_entries[i].is_wave)
destroy_sample((SAMPLE*)sound_cache_entries[i].data);
else
free(sound_cache_entries[i].data);
}
sound_cache_entries[i].size = *size;
sound_cache_entries[i].data = newdata;
if (sound_cache_entries[i].file_name)
free(sound_cache_entries[i].file_name);
sound_cache_entries[i].file_name = (char*)malloc(strlen(filename) + 1);
strcpy(sound_cache_entries[i].file_name, filename);
sound_cache_entries[i].reference = 1;
sound_cache_entries[i].last_used = sound_cache_counter++;
sound_cache_entries[i].is_wave = is_wave;
_sound_cache_mutex.Unlock();
return sound_cache_entries[i].data;
}
_sound_cache_mutex.Unlock();
}
