示例#1
0
文件: bank.c 项目: EQ4/phasex
/*****************************************************************************
 * load_patch_list()
 *
 * Loads a comma separated list of patches, one for each part.
 *****************************************************************************/
void
load_patch_list(char *patch_list)
{
	PATCH           *patch;
	char            filename[PATH_MAX];
	char            *patch_name;
	char            *tokbuf;
	char            *p;
	unsigned int    part_num = 0;
	int             prog = 0;

	/* Get a comma separated client:port list from command line,
	   or a '-' (or no -p arg) for open subscription. */
	if (patch_list != NULL) {
		if ((tokbuf = alloca(strlen(patch_list) * 4)) == NULL) {
			phasex_shutdown("Out of memory!\n");
		}
		p = patch_list;
		while ((part_num < MAX_PARTS) && ((patch_name = strtok_r(p, ",", &tokbuf)) != NULL)) {
			p = NULL;
			patch = get_patch_from_bank(part_num, 0);
			/* read in patchdump for part num if patch is '-' */
			if (strcmp(patch_name, "-") == 0) {
				read_patch(user_patchdump_file[part_num], patch);
			}
			/* if patch is numeric and within range 0-127, treat it
			   as a program number */
			else if (((prog = atoi(patch_name)) > 0) && (prog <= PATCH_BANK_SIZE)) {
				session_bank[visible_sess_num].prog_num[part_num] =
					(unsigned int)(prog - 1);
			}
			/* default to reading in named patch */
			else {
				/* TODO: if user patch exists (in any directory) load it and
				   skip system patch. */
				snprintf(filename, sizeof(char) * PATH_MAX, "%s/%s.phx",
				         PATCH_DIR, patch_name);
				read_patch(filename, patch);
				snprintf(filename, sizeof(char) * PATH_MAX, "%s/%s.phx",
				         user_patch_dir, patch_name);
				read_patch(filename, patch);
				session_bank[visible_sess_num].prog_num[part_num] = (unsigned int) prog - 1;
			}
			part_num++;
		}
	}
}
示例#2
0
int lash_pollevent()
{
    if (!lash_enabled(lash_client))
        return -1;

    lash_event_t *event;
    char *l_path;
    while (event = lash_get_event(lash_client)) {
        if (lash_event_get_type(event) == LASH_Save_File) {
            lash_buffer = (char *)lash_event_get_string(event);
            l_path = (char *)malloc(strlen(lash_buffer) + 13);
            sprintf(l_path, "%s/phasex.phx", lash_buffer);
            save_patch(l_path, 0);
            sprintf(l_path, "%s/phasex.map", lash_buffer);
            save_midimap(l_path);
            lash_send_event(lash_client, lash_event_new_with_type(LASH_Save_File));
            free(l_path);
            break;
        }
        else if (lash_event_get_type(event) == LASH_Restore_File) {
            lash_buffer = (char *)lash_event_get_string(event);
            l_path = (char *)malloc(strlen(lash_buffer) + 13);
            sprintf(l_path, "%s/phasex.phx", lash_buffer);
            read_patch(l_path, 0);
            sprintf(l_path, "%s/phasex.map", lash_buffer);
            read_midimap(l_path);
            lash_send_event(lash_client, lash_event_new_with_type(LASH_Restore_File));
            free(l_path);
            break;
        }
        else if (lash_event_get_type(event) == LASH_Quit) {
            shutdown = 1;
            break;
        }
        lash_event_destroy(event);
    }
    return 0;
}
示例#3
0
文件: bank.c 项目: EQ4/phasex
/*****************************************************************************
 * load_patch_bank()
 *****************************************************************************/
void
load_patch_bank(void)
{
	PATCH           *patch;
	FILE            *bank_f;
	char            *p;
	char            *filename;
	char            *tmpname;
	char            buffer[256];
	int             part_num    = 0;
	int             prog        = 0;
	unsigned int    line        = 0;
	int             once        = 1;
	int             result;

	/* open the bank file */
	if ((bank_f = fopen(user_bank_file, "rt")) == NULL) {
		if ((bank_f = fopen(sys_bank_file, "rt")) == NULL) {
			return;
		}
	}

	/* read bank entries */
	while (fgets(buffer, sizeof(buffer), bank_f) != NULL) {
		line++;

		/* discard comments and blank lines */
		if ((buffer[0] == '\n') || (buffer[0] == '#')) {
			continue;
		}

		/* get part number */
		if ((p = get_next_token(buffer)) == NULL) {
			while (get_next_token(buffer) != NULL);
			continue;
		}
		part_num = atoi(p) - 1;
		if ((part_num < 0) || (part_num >= MAX_PARTS)) {
			part_num = 0;
		}

		/* make sure there's a comma */
		if ((p = get_next_token(buffer)) == NULL) {
			while (get_next_token(buffer) != NULL);
			continue;
		}
		if (*p != ',') {
			while (get_next_token(buffer) != NULL);
			continue;
		}

		/* get program number */
		if ((p = get_next_token(buffer)) == NULL) {
			while (get_next_token(buffer) != NULL);
			continue;
		}
		prog = atoi(p) - 1;
		if ((prog < 0) || (prog >= PATCH_BANK_SIZE)) {
			prog = 0;
		}
		patch = & (patch_bank[part_num][prog]);

		/* make sure there's an '=' */
		if ((p = get_next_token(buffer)) == NULL) {
			while (get_next_token(buffer) != NULL);
			continue;
		}
		if (*p != '=') {
			while (get_next_token(buffer) != NULL);
			continue;
		}

		/* get patch name */
		if ((tmpname = get_next_token(buffer)) == NULL) {
			while (get_next_token(buffer) != NULL);
			continue;
		}
		if (*tmpname == ';') {
			while (get_next_token(buffer) != NULL);
			continue;
		}
		if ((filename = strdup(tmpname)) == NULL) {
			phasex_shutdown("Out of memory!\n");
		}

		/* make sure there's a ';' */
		if ((p = get_next_token(buffer)) == NULL) {
			while (get_next_token(buffer) != NULL);
			continue;
		}
		if (*p != ';') {
			while (get_next_token(buffer) != NULL);
			continue;
		}

		/* flush remainder of line */
		while (get_next_token(buffer) != NULL);

		/* load patch into bank */
		result = 0;

		/* handle bare patch names from 0.10.x versions */
		if (filename[0] != '/') {
			snprintf(buffer, sizeof(buffer), "%s/%s.phx", user_patch_dir, filename);
			result = read_patch(buffer, patch);
			if (result != 0) {
				snprintf(buffer, sizeof(buffer), "%s/%s.phx", PATCH_DIR, filename);
				result = read_patch(buffer, patch);
			}
		}

		/* handle fully qualified filenames */
		else {
			result = read_patch(filename, patch);
		}

		/* initialize on failure and set name based on program number */
		if (result != 0) {
			if (read_patch(user_default_patch, patch) != 0) {
				read_patch(sys_default_patch, patch);
			}
			snprintf(buffer, sizeof(buffer), "Untitled-%04d", (prog + 1));
			tmpname = patch->name;
			patch->name = strdup(buffer);
			if (tmpname != NULL) {
				free(tmpname);
			}
			if (patch->directory != NULL) {
				free(patch->directory);
			}
			patch->directory = strdup(user_patch_dir);
		}

		/* free up memory used to piece filename together */
		free(filename);

		/* Lock some global parameters after the first patch is read */
		if (once) {
			get_param_info_by_id(PARAM_MIDI_CHANNEL)->locked = 1;
			get_param_info_by_id(PARAM_BPM)->locked          = 1;

			once = 0;
		}
	}

	/* done parsing */
	fclose(bank_f);

	/* now fill the empty bank slots with the default patch */
	for (prog = 0; prog < PATCH_BANK_SIZE; prog++) {
		patch = & (patch_bank[part_num][prog]);
		if (patch->name == NULL) {
			if (read_patch(user_default_patch, patch) != 0) {
				read_patch(sys_default_patch, patch);
			}
			snprintf(buffer, sizeof(buffer), "Untitled-%04d", (prog + 1));
			patch->name = strdup(buffer);
			patch->directory = strdup(user_patch_dir);
		}
		patch->modified = 0;
	}
}
示例#4
0
gboolean
run_command (TestProfile *tp, int zlevel, int slevel, File* from, File* to, File* out, File *re, gboolean accounting)
{
  int pid, status, outfd;
  struct stat sbuf;
  char xdelta_args[16];
  char xdelta_args2[16];
  char diff_gzargs[16];
  char gzip_args[16];

  GTimer *timer = g_timer_new ();

  sprintf (xdelta_args, "-qn%d", zlevel);
  sprintf (xdelta_args2, "-s%d", slevel);
  sprintf (diff_gzargs, "wb%d", zlevel);
  sprintf (gzip_args, "-c%d", zlevel);

  unlink (out->name);

  g_timer_start (timer);

  if ((pid = vfork()) < 0)
    return FALSE;

  if (pid == 0)
    {
      if (starts_with (tp->name, "xdelta"))
	{
	  execl (tp->progname,
		 tp->progname,
		 "delta",
		 xdelta_args,
		 xdelta_args2,
		 from->name,
		 to->name,
		 out->name,
		 NULL);
	}
      else
	{
	  outfd = open (out->name, O_CREAT | O_TRUNC | O_WRONLY, 0777);

	  if (outfd < 0)
	    {
	      perror ("open");
	      fail ();
	    }

	  dup2(outfd, STDOUT_FILENO);

	  if (close (outfd))
	    {
	      perror ("close");
	      fail ();
	    }

	  if (starts_with (tp->name, "diff"))
	    execl (tp->progname,
		   tp->progname,
		   "--rcs",
		   "-a",
		   from->name,
		   to->name,
		   NULL);
	  else if (starts_with (tp->name, "gzip"))
	    execl (tp->progname,
		   tp->progname,
		   gzip_args,
		   to->name,
		   NULL);
	  else
	    abort ();
	}

      perror ("execl failed");
      _exit (127);
    }

  if (waitpid (pid, &status, 0) != pid)
    {
      perror ("wait failed");
      fail ();
    }

  // Note: program is expected to return 0, 1 meaning diff or no diff,
  // > 1 indicates failure
  if (! WIFEXITED (status) || WEXITSTATUS (status) > 1)
    {
      g_warning ("delta command failed\n");
      fail ();
    }

  if (stat (out->name, & sbuf))
    {
      perror ("stat");
      fail ();
    }

  // Do zlib compression on behalf of diff
  if (zlevel > 0 && starts_with (tp->name, "diff"))
    {
      Patch  *patch   = read_patch (out, & sbuf);
      gzFile *rewrite = gzopen (out->name, diff_gzargs);

      if (! rewrite) fail ();

      if (gzwrite (rewrite, patch->data, patch->length) == 0) { perror ("gzwrite"); fail (); }
      if (gzclose (rewrite) != Z_OK)                          { perror ("gzclose"); fail (); }
      if (stat    (out->name, & sbuf))                        { perror ("stat");    fail (); }
    }

  g_timer_stop (timer);

  if (accounting)
    {
      add_tv (timer);
    }

  if (__dsize < 0)
    {
      __dsize = sbuf.st_size;

      // Verify only once

      if (starts_with (tp->name, "xdelta"))
	{
	  if (! xdelta_verify (tp, zlevel, slevel, from, to, out, re))
	    {
	      g_warning ("verify failed");
	      fail ();
	    }
	}
    }
  else
    {
      if (__dsize != sbuf.st_size)
	{
	  g_warning ("%s -%d: delta command produced different size deltas: %d and %d",
		     tp->progname, zlevel, (int)__dsize, (int)sbuf.st_size);
	  fail ();
	}
    }

  g_timer_destroy (timer);

  return TRUE;
}