uif_samview.c

A GTK sound font editor. Sound font files are used to synthesize instruments from audio samples for

  samview_new_marker (SAMVIEW (samview_widg), &clr);

  gtk_widget_show (samview_widg);
  gtk_box_pack_start (GTK_BOX (vbox), samview_widg, TRUE, TRUE, 0);

  sbar = gtk_hscrollbar_new (SAMVIEW (samview_widg)->adj);
  gtk_widget_show (sbar);
  gtk_box_pack_start (GTK_BOX (main_box), sbar, FALSE, FALSE, 0);

  gtk_widget_show (main_box);

  return (main_box);
}

static void
samview_cb_loopbtn_toggled (GtkWidget * btn)
{
  SFGenAmount *genp;
  SFGenAmount modes;
  gboolean btnactv;

  btnactv = GTK_TOGGLE_BUTTON (btn)->active;

  if (samview_mode == SAMVIEW_IZONE && uisf_selected_zone)
    {
      genp = sfont_gen_get (uisf_selected_zone, Gen_SampleModes);

      if (genp)
	modes.uword = genp->uword;
      else
	modes.uword = 0;

      if (btnactv)
	modes.uword |= SF_SAMPMODES_LOOP;
      else
	modes.uword &= ~SF_SAMPMODES_LOOP;

      sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
		     Gen_SampleModes, modes, FALSE);

      wtbl_sfitem_changed (((SFInst *)uisf_selected_elem)->itemid,
			   WTBL_ITEM_CHANGE);
    }
  else if (samview_mode == SAMVIEW_SAMPLE)
    {
      wtbl_loop_sam_as_inst = btnactv;

      wtbl_sfitem_changed (((SFSample *)uisf_selected_elem)->itemid,
			   WTBL_ITEM_CHANGE);
    }
}

/* cut sample button pressed */
static void
samview_cb_cut_button_clicked (GtkWidget * btn)
{
  SamView *samview;

  samview = SAMVIEW (samview_widg);

  if (samview_mode != SAMVIEW_SAMPLE || !sam_in_view
    || samview->select_start == -1)
    return;

  sam_cut_sample (uisf_selected_uisfont->sf, sam_in_view,
    samview->select_start, samview->select_end);

  uisf_set_sam_in_view (sam_in_view, uisf_selected_uisfont->sf, TRUE);
  samview_update ();

  wtbl_sfitem_changed (((SFSample *)uisf_selected_elem)->itemid,
		       WTBL_ITEM_CHANGE);
}

/* set sample position for the active SAMPLE/IZONE mark enumeration */
void
samview_set_samplemark_pos (gint markenum, gint32 val)
{
  SFGenAmount msamt, lsamt;

  if (samview_mode == SAMVIEW_SAMPLE)
    {				/* sample view mode */
      if (markenum == MARK_LOOPSTART)	/* set loop start? */
	SFONT_SETVAR (sam_in_view->loopstart, val, uisf_selected_uisfont->sf);
      else if (markenum == MARK_LOOPEND)	/* set loop end? */
	SFONT_SETVAR (sam_in_view->loopend, val, uisf_selected_uisfont->sf);
    }
  else
    {
      msamt.sword = val >> 15;	/* most significant 32k portion */
      lsamt.sword = val & 0x7FFF;	/* least significant portion */

      switch (markenum)
	{
	case MARK_LOOPSTART:
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_StartLoopAddrCoarseOfs, msamt, FALSE);
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_StartLoopAddrOfs, lsamt, FALSE);
	  break;
	case MARK_LOOPEND:
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_EndLoopAddrCoarseOfs, msamt, FALSE);
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_EndLoopAddrOfs, lsamt, FALSE);
	  break;
	case MARK_SAMSTARTOFS:
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_StartAddrCoarseOfs, msamt, FALSE);
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_StartAddrOfs, lsamt, FALSE);
	  break;
	case MARK_SAMENDOFS:
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_EndAddrCoarseOfs, msamt, FALSE);
	  sfont_gen_set (uisf_selected_uisfont->sf, uisf_selected_zone,
	    Gen_EndAddrOfs, lsamt, FALSE);
	  break;
	}
    }
}

/* get sample position for the active SAMPLE/IZONE mark enumeration */
gint
samview_get_samplemark_pos (gint markenum)
{
  gint pos = 0;
  SFGenAmount *msamt = NULL, *lsamt = NULL;

  if (samview_mode == SAMVIEW_SAMPLE)
    {				/* sample view mode */
      if (markenum == MARK_LOOPSTART)
	pos = sam_in_view->loopstart;
      else if (markenum == MARK_LOOPEND)
	pos = sam_in_view->loopend;
    }
  else
    {
      switch (markenum)
	{
	case MARK_LOOPSTART:
	  msamt =
	    sfont_gen_get (uisf_selected_zone, Gen_StartLoopAddrCoarseOfs);
	  lsamt = sfont_gen_get (uisf_selected_zone, Gen_StartLoopAddrOfs);
	  break;
	case MARK_LOOPEND:
	  msamt =
	    sfont_gen_get (uisf_selected_zone, Gen_EndLoopAddrCoarseOfs);
	  lsamt = sfont_gen_get (uisf_selected_zone, Gen_EndLoopAddrOfs);
	  break;
	case MARK_SAMSTARTOFS:
	  msamt = sfont_gen_get (uisf_selected_zone, Gen_StartAddrCoarseOfs);
	  lsamt = sfont_gen_get (uisf_selected_zone, Gen_StartAddrOfs);
	  break;
	case MARK_SAMENDOFS:
	  msamt = sfont_gen_get (uisf_selected_zone, Gen_EndAddrCoarseOfs);
	  lsamt = sfont_gen_get (uisf_selected_zone, Gen_EndAddrOfs);
	  break;
	case MARK_SAMLOOPSTART:
	  pos = sam_in_view->loopstart;
	  break;
	case MARK_SAMLOOPEND:
	  pos = sam_in_view->loopend;
	  break;
	}
      if (msamt)
	pos = ((gint)msamt->sword << 15);
      if (lsamt)
	pos += lsamt->sword;
    }
  return (pos);
}

/* returns the absolute bounds and padding for the specified mark enum */
static void
samview_get_samplemark_bounds (gint markenum, gint *pmin, gint *pmax,
			       gint *pminpad, gint *pmaxpad)
{
  gint min, max;		/* absolute min and max bounds */
  gint minpad, maxpad;		/* pad values for min and max */

  if (samview_mode == SAMVIEW_SAMPLE)
    {
      if (markenum == MARK_LOOPSTART)
	{
	  min = 1;		/* abs 'hard' minumum allowed */

	  /* min 'soft' padding allowed */
	  minpad = smurfcfg_get_int (SMURFCFG_SAM_MINLOOPPAD) - 1;

	  max = sam_in_view->loopend - 1;	/* abs max */

	  /* max 'soft' padding allowed */
	  maxpad = -smurfcfg_get_int (SMURFCFG_SAM_MINLOOP) + 1;
	}
      else if (markenum == MARK_LOOPEND)
	{
	  min = sam_in_view->loopstart + 1;
	  minpad = smurfcfg_get_int (SMURFCFG_SAM_MINLOOP) - 1;
	  max = sam_in_view->end;
	  maxpad = -smurfcfg_get_int (SMURFCFG_SAM_MINLOOPPAD) + 1;
	}
    }
  else
    {
      switch (markenum)
	{
	case MARK_LOOPSTART:
	  min = samview_get_samplemark_pos (MARK_SAMSTARTOFS)
	    - sam_in_view->loopstart + 1;
	  minpad = smurfcfg_get_int (SMURFCFG_SAM_MINLOOPPAD) - 1;
	  max = (samview_get_samplemark_pos (MARK_SAMLOOPEND)
	    + samview_get_samplemark_pos (MARK_LOOPEND))
	    - samview_get_samplemark_pos (MARK_SAMLOOPSTART) - 1;
	  maxpad = -smurfcfg_get_int (SMURFCFG_SAM_MINLOOP) + 1;
	  break;
	case MARK_LOOPEND:
	  min = (samview_get_samplemark_pos (MARK_SAMLOOPSTART)
	    + samview_get_samplemark_pos (MARK_LOOPSTART))
	    - sam_in_view->loopend + 1;
	  minpad = smurfcfg_get_int (SMURFCFG_SAM_MINLOOP) - 1;
	  max =
	    (sam_in_view->end + samview_get_samplemark_pos (MARK_SAMENDOFS)) -
	    samview_get_samplemark_pos (MARK_SAMLOOPEND);
	  maxpad = -smurfcfg_get_int (SMURFCFG_SAM_MINLOOPPAD) + 1;
	  break;
	case MARK_SAMSTARTOFS:
	  min = 0;
	  minpad = 0;
	  max = (samview_get_samplemark_pos (MARK_SAMLOOPSTART)
	    + samview_get_samplemark_pos (MARK_LOOPSTART)) - 1;
	  maxpad = -smurfcfg_get_int (SMURFCFG_SAM_MINLOOPPAD) + 1;
	  break;
	case MARK_SAMENDOFS:
	  min = (samview_get_samplemark_pos (MARK_SAMLOOPEND)
	    + samview_get_samplemark_pos (MARK_LOOPEND))
	    - sam_in_view->end + 1;
	  minpad = smurfcfg_get_int (SMURFCFG_SAM_MINLOOPPAD) - 1;
	  max = 0;
	  maxpad = 0;
	  break;
	}
    }

  *pmin = min;
  *pmax = max;
  *pminpad = minpad;
  *pmaxpad = maxpad;
}

/* clamp pos to valid range for the specified mark enum */
static gint
samview_clamp_samplemark_pos (gint markenum, gint val)
{
  gint min, max;		/* absolute min and max values to clamp to */
  gint minpad, maxpad;		/* minimum padding */

  samview_get_samplemark_bounds (markenum, &min, &max, &minpad, &maxpad);

/* pos is clamped to ensure that the minumum padding amount is satisfied
  (min + minpad <= val <= max + maxpad), except where SAMPLE/IZONE
  values already break min pad amounts, then the value is clamped to min, max */

  /* loop points already break minloop/padding sizes? */
  if (min + minpad > max + maxpad)
    {
      /* ?: yes, clamp to absolute min/max */
      return (CLAMP (val, min, max));
    }
  else
    {
      /* ?: no, 'soft' clamp to ensure minimum padding */
      return (CLAMP (val, min + minpad, max + maxpad));
    }
}

/* value in a samview spin button changed */
static void
samview_cb_spbtn_value_changed (GtkAdjustment *adj, gint markenum)
{
  gint val;
  gint pos, pos2;

  val = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (samview_spbtns
							   [markenum]));
  pos = samview_clamp_samplemark_pos (markenum, val);
  samview_set_samplemark_pos (markenum, pos);
  pos2 = pos;

  /* if this is an offset marker, then add absolute position */
  if (samview_mode == SAMVIEW_IZONE)
    {
      if (markenum == MARK_LOOPSTART)
	pos2 += samview_get_samplemark_pos (MARK_SAMLOOPSTART);
      else if (markenum == MARK_LOOPEND)
	pos2 += samview_get_samplemark_pos (MARK_SAMLOOPEND);
      else if (markenum == MARK_SAMENDOFS)
	pos2 += sam_in_view->end;
    }
  
  samview_set_marker (SAMVIEW (samview_widg), markenum, pos2);

  /* notify wavetable of change */
  if (samview_mode == SAMVIEW_IZONE)
    {
      wtbl_sfitem_changed (((SFInst *)uisf_selected_elem)->itemid,
			   WTBL_ITEM_CHANGE);
    }
  else
    {
      wtbl_sfitem_changed (((SFSample *)uisf_selected_elem)->itemid,
			   WTBL_ITEM_CHANGE);
    }

  /* update spin buttons (low and upper bounds) */
  samview_update_spin_buttons ();

  /* update pointer strip */
  samview_cb_samview_change (SAMVIEW (samview_widg));

  if (pos != val)		/* if value got clamped, update adj value */
    adj->value = pos;
}

static void
samview_cb_ptrstrip_select (GtkWidget * widg, guint ptrndx)
{
  switch (ptrndx)
    {
    case PTR_LOOPSTART:
      samview_select_marker (SAMVIEW (samview_widg), MARK_LOOPSTART);
      break;
    case PTR_LOOPEND:
      samview_select_marker (SAMVIEW (samview_widg), MARK_LOOPEND);
      break;
    case PTR_SAMSTARTOFS:
      samview_select_marker (SAMVIEW (samview_widg), MARK_SAMSTARTOFS);
      break;
    case PTR_SAMENDOFS:
      samview_select_marker (SAMVIEW (samview_widg), MARK_SAMENDOFS);
      break;
    }
}

static void
samview_cb_ptrstrip_unselect (GtkWidget * widg, guint ptrndx)
{
  samview_unselect_marker (SAMVIEW (samview_widg));
}

static void
samview_cb_ptrstrip_change (GtkWidget * widg, guint ptrndx)
{
  SamView *samview;
  GtkSVMark *mark;
  GtkPSPtr *ptr;
  gint markenum;
  gint xpos;
  gint pos, clamped, absval = 0;

  samview = SAMVIEW (samview_widg);
  if (!samview->sel_marker) return;

  mark = samview->sel_marker;
  markenum = samview_get_mark_index (samview, mark);
  ptr = (GtkPSPtr *) (PTRSTRIP (samview_ptrstrip)->selpointer->data);

  /* convert x pixel position of pointer to sample position */
  pos = samview_calc_sample_pos (samview, ptr->xpos);

  /* if this is an offset marker, then subtract absolute position */
  if (samview_mode == SAMVIEW_IZONE)
    {
      if (markenum == MARK_LOOPSTART)
	absval = samview_get_samplemark_pos (MARK_SAMLOOPSTART);
      else if (markenum == MARK_LOOPEND)
	absval = samview_get_samplemark_pos (MARK_SAMLOOPEND);
      else if (markenum == MARK_SAMENDOFS)
	absval = sam_in_view->end;

      pos -= absval;
    }

  /* clamp sample position */
  clamped = samview_clamp_samplemark_pos (markenum, pos);

  /* if value was clamped, then change ptr to reflect it */
  if (clamped != pos)
    {
      pos = clamped;
      /* if this is an offset marker, then add absolute position */
      if (samview_mode == SAMVIEW_IZONE)
	pos += absval;
      ptr->xpos = samview_calc_xpos (samview, pos);
    }

  /* set the sound font variable to sample position */
  samview_set_samplemark_pos (markenum, clamped);

  /* notify wavetable of change */
  if (samview_mode == SAMVIEW_IZONE)
    {
      wtbl_sfitem_changed (((SFInst *)uisf_selected_elem)->itemid,
			   WTBL_ITEM_CHANGE);
    }
  else
    {
      wtbl_sfitem_changed (((SFSample *)uisf_selected_elem)->itemid,
			   WTBL_ITEM_CHANGE);
    }

  /* update the spin button */
  samview_update_spin_buttons ();

  /* set selected samview marker to the xpos of the pointer */
  xpos = ptr->xpos;
  samview_set_selected_marker_xpos (samview, &xpos);
}

/* update pointers on pointer strip every time samview changes */
static void
samview_cb_samview_change (SamView * samview)
{
  GtkSVMark *mark;
  gint xpos;

  if (samview_mode == SAMVIEW_INACTIVE)
    return;

  mark = samview_get_nth_mark (samview, MARK_LOOPSTART);
  xpos = samview_calc_xpos (samview, mark->pos);
  ptrstrip_set_pointer (PTRSTRIP (samview_ptrstrip), PTR_LOOPSTART, xpos);

  mark = samview_get_nth_mark (samview, MARK_LOOPEND);
  xpos = samview_calc_xpos (samview, mark->pos);
  ptrstrip_set_pointer (PTRSTRIP (samview_ptrstrip), PTR_LOOPEND, xpos);

  if (samview_mode == SAMVIEW_IZONE)
    {
      mark = samview_get_nth_mark (samview, MARK_SAMSTARTOFS);
      xpos = samview_calc_xpos (samview, mark->pos);
      ptrstrip_set_pointer (PTRSTRIP (samview_ptrstrip), PTR_SAMSTARTOFS, xpos);

      mark = samview_get_nth_mark (samview, MARK_SAMENDOFS);
      xpos = samview_calc_xpos (samview, mark->pos);
      ptrstrip_set_pointer (PTRSTRIP (samview_ptrstrip), PTR_SAMENDOFS, xpos);
    }
}