Package net.paulhertz.pixelaudio.example

Class DeadBodyWorkFlow

java.lang.Object
processing.core.PApplet
net.paulhertz.pixelaudio.example.DeadBodyWorkFlow
All Implemented Interfaces:
PANetworkClientINF, processing.core.PConstants
public class DeadBodyWorkFlow extends processing.core.PApplet implements PANetworkClientINF

QUICK START

  1. Launch the sketch. A display window and a palette of Graphical User Interface (GUI) controls appears. The display window has an audio file preloaded. The grayscale values in the image are transcoded audio samples. An overlaid rainbow spectrum traces the Signal Path, the mapping of the audio signal to the image pixels created by the PixelMapGen multigen and managed by the PixelAudioMapper mapper. The Signal Path starts in the upper left corner and ends in the lower right corner.
  2. Drawing is already turned on, so go ahead and drag the mouse to draw a line. As in TutorialOne_03_Drawing, a brushstroke appears when you release the mouse. TutorialOne_03_Drawing gave you limited control over the attributes of the brushstroke and its associated audio parameters. In GesturePlayground, you can control nearly all the available parameters with the control palette. Building on GesturePlayground, DeadBodyWorkFlow provides a framework for live performance. It is named after one of the first works I performed using the PixelAudio library, at Experimental Sound Studio, Chicago, 2023. You can probably use it "right out of the box" by just supplying your own audio and image files.
  3. At the top of the control palette, you'll find Path Source radio buttons and sliders for setting the geometry of the brush curve. When the curve is set to Reduced Points or Curve Points, the epsilon slider will allow you to visualize changes in the curve. For the curve points representation of the curve, theCurve Points slider will add or subtract points.
  4. The control palette displays knobs for the type of audio synthesis instrument you have selected. Press the 't' key to change the instrument. The control palette will reflect the changes. The control palette provides three play modes: one for editing granular synthesis parameters, another for the sampler synthesizer, and a "play only" mode where you can play both instruments but don't have editing enabled.
  5. The controls for the Sampler are fairly simple. You can change the number of points in the curve with the geometry controls. You can also change the duration of the gesture and the number of points in it with the Resample and Duration sliders. Finally, there's a Sampler Envelope menu that will change the ADSR envelope of each sampler event point.
  6. The Granular Synth has all the controls of the Sampler synth except for the envelopes, plus many controls for granular synthesis:
    1. The Hop Mode radio buttons determine if the duration of the granular event is determined by the gesture timing data in the brushstroke's PACurveMaker instance, or by the Grain Length and Hop Length sliders.
    2. Burst Count sets the number of linear grains at each event point. Its effect is to expand the sound of the grain.
    3. Grain Length and Hop Length sliders control the spacing of the grains. Hop Length is only used for Fixed Hop Mode. Grain and Hop durations are in milliseconds.
    4. The Warp radio buttons and slider control non-linear timing changes to the gesture.
  7. There are many key commands too, including the 'o' command to load a new audio files. Some commands are particularly useful with granular synthesis:
    1. The 'q' command key will calculate the optimal number of grains in a gesture (usually in GESTURE Path Mode) and update the control palette. This can provide smooth granular synthesis even as it preserves the timing characteristic of the gesture.
    2. The 'c' command key will print configuration data to the console.
    3. The 'x' command key deletes the brush you are hovering over, if it is editable.
    4. The 'z' command key swaps the instrument type of the brush you are hovering over and changes edit mode to match.

About DeadBodyWorkFlow

DeadBodyWorkFlow uses a GUI to provide a tour of the usage and properties of the AudioBrush subclasses GranularBrush and SamplerBrush, the GestureSchedule class, and the Sampler and Granular audio synthesis instruments PASamplerInstrumentPool and PAGranularInstrumentDirector. An AudioBrush combines a PACurveMaker and a GestureGranularConfig.Builder. PACurveMaker models gestures, one of the core concepts of PixelAudio. In its simplest encoded form, the PAGesture interface, a gesture consists of an array of points and an array of times. The times array and the points array must be the same size, because the times array records the times when something as-yet-unspecified will happen at the corresponding point in the points array. In my demos for PixelAudio, what happens at a point is typically an audio event and an animation event. The sound happens at the point because points in PixelAudio map onto locations in the sound buffer. Mapping of bitmap locations onto audio buffer indices is another core concept of PixelAudio. Gestures over the 2D space of an image become paths through audio buffers. The audio buffer is traversed either by a granular synthesis engine or by a sampling synthesizer. For the granular synth, a gesture corresponds to a non-linear traversal of an audio buffer, potentially as a continuous sequence of overlapping grains with a single envelope. The sampling synthesizer treats each point as a discrete event with its own envelope. Depending on how gestures and schedules are structured, the two synthesizers can sound very similar, but there are possibilities in each that the other cannot realize. As you might expect, GranularBrush implements granular synth events and SamplerBrush implements sampler synth events. Both rely on PACUrveMaker which, in addition to capturing the raw gesture of drawing a line, provides methods to reduce points / times and create Bezier paths. PACurveMaker data can also be modified by changing duration, interpolating samples, or non-linear time warping. DeadBodyWorkFlow uses GestureScheduleBuilder to interpolate and warp time and point lists.

The parameters for gesture modeling, granular and sampling synthesis, time and sample interpolation, and audio events are modeled in the GUI, which uses GestureGranularConfig.Builder gConfig to track its current state. A GestureGranularConfig instance is associated with each AudioBrush. When you click on an AudioBrush and activate it, its configuration data is loaded to the GUI and you can edit it. It will be saved to the brush when you select another brush or change the edit mode. When a brush is activated with a click, the schedule is built from its PACurveMaker and GestureGranularConfig.Builder instance variables: 

GestureSchedule schedule = scheduleBuilder.build(gb.curve(), cfg.build(), audioOut.sampleRate());

The calling chain for a GranularBrush:
mouseClicked() calls scheduleGranularBrushClick(gb, x, y);.
In scheduleGranularBrushClick(...) we get a reference to the audio buffer buf and then use the PACurveMaker object gb.curve() and gb.snapshot() to build a GestureSchedule, sched.
sched gets timing and location information for the gesture from gb.curve() and modifies it with the settings from the control palette which are stored gb.snapshot().
We port the granular synthesis parameters from the brush to a GestureGranularParams object, and then call playGranularGesture(buf, sched, gParams) to play the granular synth. We also call storeGranularCurveTL(...), which sets up UI animation events to track the grains.
Parameter buf is the audio signal that is the source of our grains, parameter sched provides the points and times for grains and parameter params provides the core parameters for granular synthesis.
playGranularGesture() builds arrays for buffer position and pan for each individual grain and then calls gDir.playGestureNow(buf, sched, params, startIndices, panPerGrain) to play the PAGranularInstrumentDirector granular synth. The 'p' command key can toggle per-grain pitch jitter, which calls playGestureNow()in a slightly different way. See playGranularGesture() for details.
PAGranularInstrumentDirector its own calling chain that goes all the way down to the individual sample level using the Minim library's UGen interface. If you just want to play music, you'll probably never have to deal with the hierarchy of classes directly, but comments PAGranularInstrumentDirector may be useful.

Part of the calling chain for a SamplerBrush:
mouseClicked() calls scheduleSamplerBrushClick(sb, x, y).
In scheduleSamplerBrushClick() we get array of points on the curve with getPathPoints(sb) and then use sb.snapshot() and scheduleBuilder.build() to build a GestureSchedule
Finally, we pass the schedule, snapshot and start time to storeSamplerBrushEvents(), an array of SamplerBrushEvent objects that is checked at every pass through the draw() loop and posts both Sampler instrument triggers and animation events. Unlike the Granular instrument, which requires very accurate timing, the Sampler synth requires less precision, so we can handle it through the UI frames. Sample-accurate timing is a topic for another as-yet-unreleased example sketch.
The runSamplerBrushEvents() method executes the UI brushstroke animation and the Sampler audio events. Sampler events all pass through pool.playSample(samplePos, samplelen, amplitude, env, pitch, pan). 

 Press UP ARROW to increase audio output volume by 3.0 dB.
 Press DOWN ARROW to decrease audio output volume by 3.0 dB.
 Numeric keys are reserved for presets which affect new brushes. See the PerformancePreset enum
   If you are using presets with PerformancePreset, '0' is reserved for clearing the preset stack.
 Press ' ' to spacebar triggers a brush if we're hovering over a brush, otherwise it triggers a point event.
 Press 'c' or 'C' to print the current configuration status to the console.
 Press 't' to switch between Granular and Sampler editing and playing.
 Press 'z' to change the drawing mode of the hover brush.
 Press 'd' to toggle doPlayOnDraw to play when a drawing gesture ends, if true.
 Press 'D' to toggle doPlayWhileDrawing to play while drawing a gesture, if true.
 Press 'p' to jitter the pitch of granular gestures.
 Press 'k' to apply the hue and saturation in the colors array to mapImage (not to baseImage).
 Press 'K' to apply hue and saturation in colors to baseImage and mapImage.
 Press 'b' or 'B' to toggle loading data to both image and audio buffers when you open either an image or an audio file.
 Press 'f' or 'F' to open a folder with JSON brush data and load all files.
 Press 'j' to save the active brush curve and config to JSON files.
 Press 'J' to save all brushes curve and config to JSON Session file.
 Press 'o' to open an audio file, image file, or JSON file.
 Press 'm' to toggle doMagicClick .
 Press 'R' to reset transform of active brush.
 Press 'r' to reset synths to defaults .
 Press 'q' to automatically set an active GRANULAR brush to have an optimized number of samples.
 Press 'u' to toggle granular sample optimization: same as the 'q' command, applied on brushstroke creation.
 Press 'g' to create a beatBrush.
 Press 'G' to create a beatBrush.
 Press 'l' to loop hovered granular brush 4 times.
 Press 'L' to infinite loop on hovered granular brush.
 Press ';' to stop loop for hovered brush.
 Press ':' to stop all loops.
 Press 'x' to delete the current active brush shape or the oldest brush shape.
 Press 'X' to delete the most recent brush shape.
 Press '≈' to option-x on MacOS keyboard, clear all brushes.
 Press '`' to fade out all instruments.
 Press 'h' or 'H' to show help message.

MacOS AUDIO TO MAX SETUP In MacOS: Ignore Sound.inputDevice() and Sound.outputDevice(), use the System Settings instead. Set Output to BlackHole 16ch Set Input to your external audio hardware, for an external mic: mine is Volt2 Then in Max Audio Status control panel: Set Input Device to BlackHole 16ch Set Output Device to your external audio hardware, e.g. Volt2 Create a patcher that gets signals from an adc~, route the adc~ to some sort of effects and out to a dac~.

  • Field Details

    • pixelaudio

      PixelAudio pixelaudio

    • multigen

      MultiGen multigen

    • genWidth

      int genWidth

    • genHeight

      int genHeight

    • mapper

      PixelAudioMapper mapper

    • mapSize

      int mapSize

    • baseImage

      processing.core.PImage baseImage

    • mapImage

      processing.core.PImage mapImage

    • chan

      PixelAudioMapper.ChannelNames chan

    • colors

      int[] colors

    • audioFile

      File audioFile

    • audioFilePath

      String audioFilePath

    • audioFileName

      String audioFileName

    • audioFileTag

      String audioFileTag

    • audioFileLength

      int audioFileLength

    • imageFile

      File imageFile

    • imageFilePath

      String imageFilePath

    • imageFileName

      String imageFileName

    • imageFileTag

      String imageFileTag

    • imageFileWidth

      int imageFileWidth

    • imageFileHeight

      int imageFileHeight

    • isLoadToBoth

      boolean isLoadToBoth

    • isBlending

      boolean isBlending

    • minim

      ddf.minim.Minim minim
      Minim audio library

    • audioOut

      ddf.minim.AudioOutput audioOut

    • isBufferStale

      boolean isBufferStale

    • sampleRate

      float sampleRate

    • fileSampleRate

      float fileSampleRate

    • bufferSampleRate

      float bufferSampleRate

    • audioSignal

      float[] audioSignal

    • playBuffer

      ddf.minim.MultiChannelBuffer playBuffer

    • samplePos

      int samplePos

    • audioLength

      int audioLength

    • samplerEnv

      ADSRParams samplerEnv

    • granularEnv

      ADSRParams granularEnv

    • maxAmplitude

      float maxAmplitude

    • attackTime

      float attackTime

    • decayTime

      float decayTime

    • sustainLevel

      float sustainLevel

    • releaseTime

      float releaseTime

    • pitchScaling

      float pitchScaling

    • defaultPitchScaling

      float defaultPitchScaling

    • lowPitchScaling

      float lowPitchScaling

    • highPitchScaling

      float highPitchScaling

    • envIsGranular

      boolean envIsGranular

    • grainDuration

      int grainDuration

    • noteDuration

      int noteDuration

    • oldNoteDuration

      int oldNoteDuration

    • samplelen

      int samplelen

    • samplerGain

      float samplerGain

    • samplerPointGain

      float samplerPointGain

    • outputGain

      float outputGain

    • isMuted

      boolean isMuted

    • pool

      PASamplerInstrumentPool pool

    • sMaxVoices

      int sMaxVoices

    • granSignal

      public float[] granSignal

    • gSynth

      public PAGranularInstrument gSynth

    • curveSteps

      public int curveSteps

    • granLength

      public int granLength

    • granHop

      public int granHop

    • gMaxVoices

      public int gMaxVoices

    • currentGranStatus

      String currentGranStatus

    • gDir

      public PAGranularInstrumentDirector gDir

    • granularGain

      public float granularGain

    • granularPointGain

      public float granularPointGain

    • useShortGrain

      boolean useShortGrain

    • longSample

      int longSample

    • shortSample

      int shortSample

    • granSamples

      int granSamples

    • hopSamples

      int hopSamples

    • gParamsFixed

      GestureGranularParams gParamsFixed

    • gParamsDraw

      GestureGranularParams gParamsDraw

    • useLongBursts

      boolean useLongBursts

    • maxBurstGrains

      int maxBurstGrains

    • burstGrains

      int burstGrains

    • shift

      int shift

    • leap

      int leap

    • totalShift

      int totalShift

    • isAnimating

      boolean isAnimating

    • oldIsAnimating

      boolean oldIsAnimating

    • isTrackMouse

      boolean isTrackMouse

    • animSteps

      int animSteps

    • isRecordingVideo

      boolean isRecordingVideo

    • videoFrameRate

      int videoFrameRate

    • videoSteps

      int videoSteps

    • step

      int step

    • videx

      com.hamoid.VideoExport videx

    • curveMaker

      public PACurveMaker curveMaker

    • isDrawMode

      public boolean isDrawMode

    • epsilon

      public float epsilon

    • currentPoint

      public processing.core.PVector currentPoint

    • allPoints

      public ArrayList<processing.core.PVector> allPoints

    • allTimes

      public ArrayList<Integer> allTimes

    • startTime

      public int startTime

    • dragColor

      public int dragColor

    • dragWeight

      public float dragWeight

    • polySteps

      public int polySteps

    • readyGranColor

      int readyGranColor

    • hoverGranColor

      int hoverGranColor

    • activeGranColor

      int activeGranColor

    • readySamplerColor

      int readySamplerColor

    • hoverSamplerColor

      int hoverSamplerColor

    • activeSamplerColor

      int activeSamplerColor

    • dimmedBrushColor

      int dimmedBrushColor

    • circleColor

      int circleColor

    • dimCircleColor

      int dimCircleColor

    • lineColor

      int lineColor

    • dimLineColor

      int dimLineColor

    • animatedCircleColor

      int animatedCircleColor

    • isIgnoreOutsideBounds

      boolean isIgnoreOutsideBounds

    • hoverBrush

      private AudioBrush hoverBrush
      AudioBrush wraps a PACurveMaker (gesture) and a GestureGranularConfig.Builder (granular synthesis parameters)

    • hoverIndex

      private int hoverIndex

    • activeBrush

      private AudioBrush activeBrush

    • granularBrushes

      ArrayList<GranularBrush> granularBrushes

    • activeGranularBrush

      GranularBrush activeGranularBrush

    • activeGranularIndex

      int activeGranularIndex

    • samplerBrushes

      ArrayList<SamplerBrush> samplerBrushes

    • activeSamplerBrush

      SamplerBrush activeSamplerBrush

    • activeSamplerIndex

      int activeSamplerIndex

    • pointTimeLocs

      ArrayList<TimedLocation> pointTimeLocs

    • samplerBrushEvents

      ArrayList<SamplerBrushEvent> samplerBrushEvents

    • grainTimeLocs

      ArrayList<TimedLocation> grainTimeLocs

    • pointTimeLocsLock

      final Object pointTimeLocsLock

    • samplerBrushEventsLock

      final Object samplerBrushEventsLock

    • grainTimeLocsLock

      final Object grainTimeLocsLock

    • pointEventUseSampler

      boolean pointEventUseSampler

    • runningFadeOut

      boolean runningFadeOut

    • gConfig

      GestureGranularConfig.Builder gConfig

    • defaultGranConfig

      final GestureGranularConfig.Builder defaultGranConfig

    • defaultSampConfig

      final GestureGranularConfig.Builder defaultSampConfig

    • guiSyncing

      boolean guiSyncing

    • baselineCount

      int baselineCount

    • baselineDurationMs

      int baselineDurationMs

    • scheduleBuilder

      GestureScheduleBuilder scheduleBuilder

    • drawingMode

      DeadBodyWorkFlow.DrawingMode drawingMode

    • CURVE_STEPS_HARD_MAX

      static final int CURVE_STEPS_HARD_MAX
      See Also:

    • CURVE_STEPS_SAFE_MAX

      static final int CURVE_STEPS_SAFE_MAX
      See Also:

    • CURVE_STEPS_FLOOR

      static final int CURVE_STEPS_FLOOR
      See Also:

    • audioSched

      AudioScheduler<DeadBodyWorkFlow.Happening> audioSched

    • audioBlockStartSample

      private final AtomicLong audioBlockStartSample

    • audioNextBlockStartSample

      private final AtomicLong audioNextBlockStartSample

    • hopScale

      float hopScale

    • optGrainCount

      int optGrainCount

    • eventStep

      int eventStep

    • isSaveConfig

      boolean isSaveConfig

    • drawTasteIntervalMs

      int drawTasteIntervalMs

    • drawTasteMinDist

      float drawTasteMinDist

    • drawTasteDurationMs

      int drawTasteDurationMs

    • drawTasteMaxGrains

      int drawTasteMaxGrains

    • drawTasteBurstGrains

      int drawTasteBurstGrains

    • lastDrawTasteMs

      int lastDrawTasteMs

    • lastDrawTastePoint

      processing.core.PVector lastDrawTastePoint

    • activeLoops

      final ArrayList<DeadBodyWorkFlow.InstrumentLoop> activeLoops

    • presetStack

      ArrayList<DeadBodyWorkFlow.PerformancePreset> presetStack

    • isVerbose

      boolean isVerbose

    • isDebugging

      boolean isDebugging

    • isRunWordGame

      boolean isRunWordGame

    • doPlayOnNewBrush

      boolean doPlayOnNewBrush

    • doPlayWhileDrawing

      boolean doPlayWhileDrawing

    • isAutoOptimize

      boolean isAutoOptimize

    • doMagicClick

      boolean doMagicClick

    • usePitchedGrains

      boolean usePitchedGrains

    • pitchJitter

      float pitchJitter

    • applyColorMapOnLoad

      boolean applyColorMapOnLoad

    • isReplaceBrushes

      boolean isReplaceBrushes

    • isSaveSession

      boolean isSaveSession

    • isRaining

      boolean isRaining

    • isAddDynamics

      boolean isAddDynamics

    • dynamics

      PAControlCurve dynamics

    • isBrushTransformTest

      boolean isBrushTransformTest

    • isBrushTransformFrozen

      boolean isBrushTransformFrozen

    • isBrushSelectionModal

      boolean isBrushSelectionModal

    • daPath

      String daPath

    • daFilename

      String daFilename

    • daFilelist

      ArrayList<String> daFilelist

    • nd

      DeadBodyWorkFlow.NetworkDelegate nd

    • isUseNetworkDelegate

      boolean isUseNetworkDelegate

    • isNetSendDrawingPoints

      boolean isNetSendDrawingPoints

    • isNetSendOutsideBrushPoints

      boolean isNetSendOutsideBrushPoints

    • isNetSendBrushTriggers

      boolean isNetSendBrushTriggers

    • isNetSendFileInfo

      boolean isNetSendFileInfo

    • isNetSendGestures

      boolean isNetSendGestures

    • controlWindow

      g4p_controls.GWindow controlWindow

    • controlPanel

      g4p_controls.GPanel controlPanel

    • pathSourceLabel

      g4p_controls.GLabel pathSourceLabel

    • pathSourceGroup

      g4p_controls.GToggleGroup pathSourceGroup

    • allOption

      g4p_controls.GOption allOption

    • rdpOption

      g4p_controls.GOption rdpOption

    • curveOption

      g4p_controls.GOption curveOption

    • rdpEpsilonSlider

      g4p_controls.GSlider rdpEpsilonSlider

    • curvePointsSlider

      g4p_controls.GSlider curvePointsSlider

    • pitchLabel

      g4p_controls.GLabel pitchLabel

    • pitchShiftText

      g4p_controls.GTextField pitchShiftText

    • resampleLabel

      g4p_controls.GLabel resampleLabel

    • resampleSlider

      g4p_controls.GSlider resampleSlider

    • resampleField

      g4p_controls.GTextField resampleField

    • durationLabel

      g4p_controls.GLabel durationLabel

    • durationSlider

      g4p_controls.GSlider durationSlider

    • durationField

      g4p_controls.GTextField durationField

    • burstLabel

      g4p_controls.GLabel burstLabel

    • burstSlider

      g4p_controls.GSlider burstSlider

    • hopModeLabel

      g4p_controls.GLabel hopModeLabel

    • hopModeGroup

      g4p_controls.GToggleGroup hopModeGroup

    • gestureOption

      g4p_controls.GOption gestureOption

    • grainLengthLabel

      g4p_controls.GLabel grainLengthLabel

    • grainLengthSlider

      g4p_controls.GSlider grainLengthSlider

    • hopLengthLabel

      g4p_controls.GLabel hopLengthLabel

    • hopLengthSlider

      g4p_controls.GSlider hopLengthSlider

    • fixedOption

      g4p_controls.GOption fixedOption

    • warpLabel

      g4p_controls.GLabel warpLabel

    • warpSlider

      g4p_controls.GSlider warpSlider

    • epsilonSliderLabel

      g4p_controls.GLabel epsilonSliderLabel

    • curvePointsLabel

      g4p_controls.GLabel curvePointsLabel

    • gainLabel

      g4p_controls.GLabel gainLabel

    • gainSlider

      g4p_controls.GSlider gainSlider

    • grainLengthField

      g4p_controls.GTextField grainLengthField

    • hopLengthField

      g4p_controls.GTextField hopLengthField

    • warpGroup

      g4p_controls.GToggleGroup warpGroup

    • linearWarpOption

      g4p_controls.GOption linearWarpOption

    • expWarpOption

      g4p_controls.GOption expWarpOption

    • squareRootOption

      g4p_controls.GOption squareRootOption

    • customWarpOption

      g4p_controls.GOption customWarpOption

    • arcLengthTimeOption

      g4p_controls.GOption arcLengthTimeOption

    • envelopeLabel

      g4p_controls.GLabel envelopeLabel

    • envelopeMenu

      g4p_controls.GDropList envelopeMenu

    • ENV_CUSTOM

      static final String ENV_CUSTOM
      See Also:

    • adsrItems

      String[] adsrItems

    • envelopeValuesLabel

      g4p_controls.GLabel envelopeValuesLabel

    • commentsField

      g4p_controls.GTextArea commentsField

  • Constructor Details

    • DeadBodyWorkFlow

      public DeadBodyWorkFlow()

  • Method Details

    • main

      public static void main(String[] args)
      Parameters:
      args -

    • settings

      public void settings()
      Overrides:
      settings in class processing.core.PApplet

    • setup

      public void setup()
      Overrides:
      setup in class processing.core.PApplet

    • stop

      public void stop()
      turn off audio processing when we exit
      Overrides:
      stop in class processing.core.PApplet

    • loadWordGen

      public MultiGen loadWordGen(int wordGenW, int wordGenH)
      Adds PixelMapGen objects to the local variable genList. The genList initializes a MultiGen, which can be used to map audio and pixel data. This method follows the words in the workFlowPanel.png graphic.

    • getColors

      public int[] getColors(int size)
      Generates an array of rainbow colors using the HSB color space.
      Parameters:
      size - the number of entries in the colors array
      Returns:
      an array of RGB colors ordered by hue

    • initImages

      public void initImages()
      Initializes mapImage with the colors array. MapImage handles the color data for mapper and also serves as our display image. BaseImage is intended as a reference image that usually only changes when you open a new image file.

    • initDrawing

      public void initDrawing()
      Initializes drawing and drawing interaction variables.

    • initConfig

      public void initConfig()
      Initializes default settings for granular synthesis, defaultGranConfig, and for sampler synthesis, defaultSampConfig.

    • initGUI

      public void initGUI()
      Initializes the control palette.

    • initCustomSettings

      void initCustomSettings()

    • initNetwork

      void initNetwork()

    • preloadFiles

      public void preloadFiles(String path, String fileName)
      Preload an audio file using a file path and a filename.
      Parameters:
      path - the fully qualified path to the file's directory, ending with a '/'
      fileName - the name of the file

    • draw

      public void draw()
      Overrides:
      draw in class processing.core.PApplet

    • animate

      public void animate()

    • stepAnimation

      public void stepAnimation()
      Step through the animation, called by the draw() method. Will also record a frame of video, if we're recording.

    • renderFrame

      public void renderFrame(int step)
      Renders a frame of animation: moving along the signal path, copies baseImage pixels to mapImage pixels, adjusting the index position of the copy using totalShift -- i.e. we don't actually rotate the pixels, we just shift the position they're copied to.
      Parameters:
      step - current animation step

    • handleDrawing

      public void handleDrawing()
      Handles user's drawing actions, draws previously recorded brushstrokes, tracks and generates animation and audio events.

    • findHoverHit

      DeadBodyWorkFlow.BrushHit findHoverHit()
      Returns:
      a reference to the brushstroke the mouse is over, or null if there's no brushstroke.

    • updateHover

      void updateHover()
      Update the hoverBrush and hoverIndex global variables.

    • getBrushInRect

      DeadBodyWorkFlow.BrushHit getBrushInRect(int x, int y, int wStep, int hStep)

    • containsPoint

      public static boolean containsPoint(float x, float y, float[] r)
      Parameters:
      x - x-coordinate of point to test
      y - y-coordinate of point to test
      r - rectangle to test
      Returns:
      true if r contains the specified point

    • writeToScreen

      public void writeToScreen(String msg, int x, int y, int weight, boolean isWhite)
      Displays a line of text to the screen, usually in the draw loop. Handy for debugging. typical call: writeToScreen("When does the mind stop and the world begin?", 64, 1000, 24, true);
      Parameters:
      msg - message to write
      x - x coordinate
      y - y coordinate
      weight - font weight
      isWhite - if true, white text, otherwise, black text

    • mousePressed

      public void mousePressed()
      The built-in mousePressed handler for Processing, used to begin drawing.
      Overrides:
      mousePressed in class processing.core.PApplet

    • mouseDragged

      public void mouseDragged()
      Overrides:
      mouseDragged in class processing.core.PApplet

    • mouseReleased

      public void mouseReleased()
      Overrides:
      mouseReleased in class processing.core.PApplet

    • mouseClicked

      public void mouseClicked()
      Overrides:
      mouseClicked in class processing.core.PApplet

    • keyPressed

      public void keyPressed()
      built-in keyPressed handler, forwards events to parseKey.
      Overrides:
      keyPressed in class processing.core.PApplet

    • parseKey

      public void parseKey(char key, int keyCode)
      Handles key press events passed on by the built-in keyPressed method. By moving key event handling outside the built-in keyPressed method, we make it possible to post key commands without an actual key event. Methods and interfaces and even other threads can call parseKey(). This opens up many possibilities and a some risks, too.
      Specified by:
      parseKey in interface PANetworkClientINF
      Parameters:
      key -
      keyCode -

    • showHelp

      public void showHelp()
      to generate help output, run RegEx search/replace on parseKey case lines with: // case ('.'): // (.+) // println(" * Press $1 to $2.");

    • numericKey

      void numericKey(char key)
      Parameters:
      key -

    • runPerformancePreset

      public void runPerformancePreset(DeadBodyWorkFlow.PerformancePreset cue, char key)
      Parameters:
      key -

    • runPerformanceCue

      void runPerformanceCue(char key)
      Parameters:
      key -

    • resetPerformanceState

      void resetPerformanceState()

    • applyColorMapToDisplay

      public void applyColorMapToDisplay(boolean updateBaseImage)

    • openBrushEditor

      public void openBrushEditor(AudioBrush brush)

    • setAudioGain

      public void setAudioGain(float g)
      Sets audioOut.gain.
      Parameters:
      g - gain value for audioOut, in decibels

    • setMode

      void setMode(DeadBodyWorkFlow.DrawingMode newMode)
      Sets the drawing mode.
      Parameters:
      newMode -

    • optimizeActiveBrush

      public void optimizeActiveBrush()
      optimize grainCount for the activeBrush, most useful for granular brushes

    • resetConfigForMode

      void resetConfigForMode()
      Reset tool config to defaults (copy, so default config never mutates).

    • fadeOutGranularNow

      public void fadeOutGranularNow()

    • stopGranularNow

      public void stopGranularNow()

    • suspendScheduledEvents

      public void suspendScheduledEvents()

    • generateSamplerBeatBrush

      public SamplerBrush generateSamplerBeatBrush(int count, int intervalMs)

    • generateGranularBeatBrush

      public GranularBrush generateGranularBeatBrush(int count, int intervalMs)

    • raindrops

      public void raindrops()
      Trigger a sample at a random location.

    • runRaindropPointEvent

      void runRaindropPointEvent(int x, int y)
      Plays a sample and animates a point
      Parameters:
      x - x-coordinate of event
      y - y-coordinate of event

    • chooseFile

      public void chooseFile()
      Wrapper method for Processing's selectInput command

    • fileSelected

      public void fileSelected(File selectedFile)
      callback method for chooseFile(), handles standard audio and image formats for Processing. If a file has been successfully selected, continues with a call to loadAudioFile() or loadImageFile().
      Parameters:
      selectedFile - the File the user selected

    • loadAudioFile

      public void loadAudioFile(File audFile)
      Attempts to load audio data from a selected file into playBuffer, then calls writeAudioToImage() to transcode audio data and write it to mapImage. Resamples files that are recorded with a different sample rate than the current audio output. If you want to load the image file and audio file separately, comment out writeAudioToImage().
      Parameters:
      audFile - an audio file

    • loadImageFile

      public void loadImageFile(File imgFile)
      Attempts to load image data from a selected file into mapImage, then calls writeImageToAudio() to transcode HSB brightness channel to audio and writes it to playBuffer and audioSignal.
      Parameters:
      imgFile - an image file

    • writeAudioToImage

      public void writeAudioToImage(float[] sig, PixelAudioMapper mapper, processing.core.PImage img, PixelAudioMapper.ChannelNames chan)
      Transcodes audio data in sig[] and writes it to color channel chan of mapImage using the lookup tables in mapper to redirect indexing. Calls mapper.mapSigToImg(), which will throw an IllegalArgumentException if sig.length != img.pixels.length or sig.length != mapper.getSize().
      Parameters:
      sig - an array of float, should be audio data in the range [-1.0, 1.0]
      mapper - a PixelAudioMapper
      img - a PImage
      chan - a color channel

    • setAlphaWithBlack

      public int setAlphaWithBlack(int argb, int alpha)
      Sets the alpha channel of an RGBA color, conditionally setting alpha = 0 if all other channels = 0.
      Parameters:
      argb - an RGBA color value
      alpha - the desired alpha value to apply to argb
      Returns:
      the argb color with changed alpha channel value

    • setAlpha

      public static int setAlpha(int argb, int alpha)
      Sets the alpha channel of an RGBA color.
      Parameters:
      argb - an RGBA color value
      alpha - the desired alpha value to apply to argb
      Returns:
      the argb color with changed alpha channel value

    • writeImageToAudio

      public void writeImageToAudio(processing.core.PImage img, PixelAudioMapper mapper, float[] sig, PixelAudioMapper.ChannelNames chan, int shift)
      This method writes a color channel from an image to playBuffer, fulfilling a central concept of the PixelAudio library: image is sound. Calls mapper.mapImgToSig(), which will throw an IllegalArgumentException if img.pixels.length != sig.length or img.width * img.height != mapper.getWidth() * mapper.getHeight(). Sets totalShift = 0 on completion: the image and audio are now in sync. TODO
      Parameters:
      img - a PImage, a source of data
      mapper - a PixelAudioMapper, handles mapping between image and audio signal
      sig - an target array of float in audio format
      chan - a color channel
      shift - number of indices to shift

    • renderMapImageToAudio

      public void renderMapImageToAudio(PixelAudioMapper.ChannelNames chan)
      Writes a specified channel of mapImage to audioSignal.
      Parameters:
      chan - the selected color channel

    • commitMapImageToBaseImage

      public void commitMapImageToBaseImage()
      Writes the mapImage, which may change with animation, to the baseImage, a reference image that usually only changes when a new file is loaded.

    • commitNewBaseImage

      public void commitNewBaseImage(processing.core.PImage img)
      Copies the supplied PImage to mapImage and baseImage, sets totalShift to 0 (the images are identical).
      Parameters:
      img -

    • refreshMapImageFromBase

      public void refreshMapImageFromBase()
      Writes baseImage to mapImage with an index position offset of totalShift.

    • saveGestureJSON

      void saveGestureJSON(boolean saveSession)

    • jsonFileSelectedWrite

      public void jsonFileSelectedWrite(File jsonFile)
      Save the curve and config data from the current activeBrush.
      Parameters:
      jsonFile - initially, the file to save to (naming conventions may change the full name)

    • saveSessionJSON

      public void saveSessionJSON(File jsonFile)

    • loadGestureJSON

      void loadGestureJSON()

    • jsonFileSelectedRead

      public void jsonFileSelectedRead(File jsonFile)

    • chooseGestureLibraryFolder

      void chooseGestureLibraryFolder()

    • gestureLibraryFolderSelected

      public void gestureLibraryFolderSelected(File folder)

    • initAudio

      public void initAudio()
      CALL THIS METHOD IN SETUP() Initializes Minim audio library and audio variables.

    • initTimedEventLists

      public void initTimedEventLists()
      Initialize lists of TimedLocation objects, used for animated response to mouse clicks on brushstrokes and outside brushstrokes.

    • getSamplePos

      public int getSamplePos(int x, int y)
      Calculates the index of the image pixel within the signal path, taking the shifting of pixels and audioSignal into account. See MusicBoxBuffer for use of a windowed buffer in this calculation.
      Parameters:
      x - an x coordinate within mapImage and display bounds
      y - a y coordinate within mapImage and display bounds
      Returns:
      the index of the sample corresponding to (x,y) on the signal path

    • getCoordFromSignalPos

      public processing.core.PVector getCoordFromSignalPos(int pos)
      Parameters:
      pos - an index into the audio signal
      Returns:
      a PVector representing the image pixel mapped to pos

    • runSamplerPointEvent

      void runSamplerPointEvent(int x, int y)
      Plays a sample and animates a point
      Parameters:
      x - x-coordinate of event
      y - y-coordinate of event

    • runSamplerDrawEvent

      void runSamplerDrawEvent(int x, int y)
      Plays a sample and animates a point
      Parameters:
      x - x-coordinate of event
      y - y-coordinate of event

    • runGranularPointEvent

      void runGranularPointEvent(int x, int y)
      Plays a granular burst and animates a point
      Parameters:
      x - x-coordinate of event
      y - y-coordinate of event

    • playGranularGesture

      public void playGranularGesture(float[] buf, GestureSchedule sched, GestureGranularParams params)
      Primary method for playing a granular synthesis audio event.
      Parameters:
      buf - an audio signal as a array of float
      sched - GestureSchedule (points + times) for grains
      params - core parameters for granular synthesis

    • playGranularGesture

      public void playGranularGesture(float[] buf, GestureSchedule sched, GestureGranularParams params, GestureEventParams eventParams)
      Primary method for playing a granular synthesis audio event.
      Parameters:
      buf - an audio signal as a array of float
      sched - GestureSchedule (points + times) for grains
      params - core parameters for granular synthesis
      eventParams - event parameters for granular synthesis

    • prepareGranularGesture

      public GestureEventParams prepareGranularGesture(float[] buf, GestureSchedule sched, GestureGranularParams params)

    • prepareGranularGesture

      public GestureEventParams prepareGranularGesture(float[] buf, GestureSchedule sched, GestureGranularParams params, PAControlCurve gainCurve)

    • generateJitterPitch

      float[] generateJitterPitch(int length, float basePitch, float deviationPitch)

    • calculateEnvelopeDb

      public ADSRParams calculateEnvelopeDb(float gainDb, int totalSamples, float sampleRate)
      Calculate an envelope of length totalSamples.
      Parameters:
      gainDb - desired gain in dB, currently ignored
      totalSamples - number of samples the envelope should cover
      sampleRate - sample rate of the audio buffer the envelope is applied to
      Returns:
      and ADSRParams envelope

    • calculateEnvelopeLinear

      public ADSRParams calculateEnvelopeLinear(float linear, float totalMs)
      Calculate an envelope of length totalSamples.
      Parameters:
      linear - linear gain, ignored
      totalMs - duration of envelope in milliseconds
      Returns:
      an ADSRParams envelope

    • playSample

      public int playSample(int samplePos, int samplelen, float amplitude, float pan)
      Plays an audio sample with default envelope and stereo pan.
      Parameters:
      samplePos - position of the sample in the audio buffer
      samplelen - length of the sample (will be adjusted)
      amplitude - amplitude of the sample on playback
      Returns:
      the calculated sample length in samples

    • playSample

      public int playSample(int samplePos, int samplelen, float amplitude, ADSRParams env, float pan)
      Plays an audio sample with a custom envelope and stereo pan.
      Parameters:
      samplePos - position of the sample in the audio buffer
      samplelen - length of the sample (will be adjusted)
      amplitude - amplitude of the sample on playback
      env - an ADSR envelope for the sample
      pan - position of sound in the stereo audio field (-1.0 = left, 0.0 = center, 1.0 = right)
      Returns:
      the calculated sample length in samples

    • playSample

      public int playSample(int samplePos, int samplelen, float amplitude, ADSRParams env, float pitch, float pan)
      Plays an audio sample with with a custom envelope, pitch and stereo pan.
      Parameters:
      samplePos - position of the sample in the audio buffer
      samplelen - length of the sample (will be adjusted)
      amplitude - amplitude of the sample on playback
      env - an ADSR envelope for the sample
      pitch - pitch scaling as deviation from default (1.0), where 0.5 = octave lower, 2.0 = oactave higher
      pan - position of sound in the stereo audio field (-1.0 = left, 0.0 = center, 1.0 = right)
      Returns:

    • calcSampleLen

      public int calcSampleLen(int dur, float mean, float variance)
      Returns:
      a length in samples with some Gaussian variation

    • calcSampleLen

      public int calcSampleLen()

    • ensureSamplerReady

      void ensureSamplerReady()
      Prepares Sampler instruments and assets

    • ensureGranularReady

      void ensureGranularReady()
      Prepares Granular instruments and assets

    • buildGranSynth

      public PAGranularInstrument buildGranSynth(ddf.minim.AudioOutput out, ADSRParams env, int numVoices)
      Initializes a PAGranularInstrument.
      Parameters:
      out - AudioOutput for this application
      env - an ADSRParams envelope
      numVoices - number of voices for the synth
      Returns:
      a PAGranularInstrument

    • initGranularParams

      public void initGranularParams()
      Initializes gParamsFixed, a GestureGranularParams instances used for granular point events.

    • updateAudioChain

      void updateAudioChain(float[] sig)
      Bottleneck method that updates the various audio buffers when we load a new signal, typically from a file. updateAudioChain(float[] sig) is the _only_ method that should resize/pad/truncate the canonical signal and propagate it to playBuffer, audioSignal, granSignal, and sampler pool.
      Parameters:
      sig - an audio signal

    • updateInstrumentLoops

      public void updateInstrumentLoops()

    • stopAllLoops

      public void stopAllLoops()

    • stopLoopsForBrush

      public void stopLoopsForBrush(AudioBrush brush)

    • hasLoopForBrush

      public boolean hasLoopForBrush(AudioBrush brush)

    • estimateLoopDurationMs

      public int estimateLoopDurationMs(GestureSchedule sched, GestureGranularParams params)

    • estimateLoopDurationMs

      public int estimateLoopDurationMs(GestureSchedule sched, ADSRParams env, int noteLenSamples)

    • startGranularLoop

      public DeadBodyWorkFlow.InstrumentLoop startGranularLoop(GranularBrush gb, float[] buf, GestureSchedule sched, GestureGranularParams params, GestureEventParams eventParams, int repeats, int gapMs, boolean animate)

    • loopGranularBrush

      public DeadBodyWorkFlow.InstrumentLoop loopGranularBrush(GranularBrush gb, int repeats, int gapMs)

    • startSamplerLoop

      public DeadBodyWorkFlow.InstrumentLoop startSamplerLoop(SamplerBrush sb, GestureSchedule sched, ADSRParams env, int noteLenSamples, int repeats, int gapMs, boolean animate)

    • loopSamplerBrush

      public DeadBodyWorkFlow.InstrumentLoop loopSamplerBrush(SamplerBrush sb, int repeats, int gapMs)

    • applyColor

      public int[] applyColor(int[] colorSource, int[] graySource, int[] lut)
      Utility method for applying hue and saturation values from a source array of RGB values to the brightness values in a target array of RGB values, using a lookup table to redirect indexing.
      Parameters:
      colorSource - a source array of RGB data from which to obtain hue and saturation values
      graySource - an target array of RGB data from which to obtain brightness values
      lut - a lookup table, must be the same size as colorSource and graySource
      Returns:
      the graySource array of RGB values, with hue and saturation values changed
      Throws:
      IllegalArgumentException - if array arguments are null or if they are not the same length

    • applyColorShifted

      public int[] applyColorShifted(int[] colorSource, int[] graySource, int[] lut, int shift)
      Parameters:
      colorSource - a source array of RGB data from which to obtain hue and saturation values
      graySource - an target array of RGB data from which to obtain brightness values
      lut - a lookup table, must be the same size as colorSource and graySource
      shift - pixel shift from array rotation, windowed buffer, etc.
      Returns:
      the graySource array of RGB values, with hue and saturation values changed
      Throws:
      IllegalArgumentException - if array arguments are null or if they are not the same length

    • applyColorMap

      public void applyColorMap()
      Applies the Hue and Saturation of pixel values in the colors[] array to mapImage and baseImage.

    • initAllPoints

      public void initAllPoints()
      Initializes allPoints and adds the current mouse location to it.

    • handleClickOutsideBrush

      public int handleClickOutsideBrush(int x, int y)
      Respond to mousePressed events, usually by triggering an event

    • handlePlayOnDraw

      void handlePlayOnDraw(int x, int y)
      Dispatches lightweight "taste" audio while drawing. Call this only after a new drawing point has been accepted.

    • shouldTriggerDrawTaste

      boolean shouldTriggerDrawTaste(int x, int y, int nowMs)
      Shared thinning logic for draw-time tasting. Requires both: 1) enough time since the last taste 2) enough mouse movement since the last taste point

    • runSamplerDrawTaste

      void runSamplerDrawTaste(int x, int y)
      Lightweight Sampler "taste" while drawing. Short, percussive, cheap to trigger.

    • runGranularDrawTaste

      void runGranularDrawTaste(int x, int y)
      Lightweight Granular "taste" while drawing. Uses a very small fixed-hop burst gesture so the result is textured but inexpensive compared to full gesture playback.

    • isOverAnyBrush

      boolean isOverAnyBrush(int x, int y)

    • addDrawingPoint

      public void addDrawingPoint(int x, int y)
      While user is dragging the mouse and mode == Mode.DRAW_EDIT_GRANULAR or DRAW_EDIT_SAMPLER, accumulates new points to allPoints and event times to allTimes. Coordinates should be constrained to display window bounds.

    • clipToWidth

      public int clipToWidth(int x)
      Parameters:
      x - a value to constrain to the current window width
      Returns:
      the constrained value

    • clipToHeight

      public int clipToHeight(int y)
      Parameters:
      y - a value to constrain to the current window height
      Returns:
      the constrained value

    • jitterCoord

      public processing.core.PVector jitterCoord(int x, int y, int deviationPx)

    • loadGestureSchedule

      public GestureSchedule loadGestureSchedule(PACurveMaker brush, GestureGranularConfig snap)

    • initCurveMakerAndAddBrush

      public AudioBrush initCurveMakerAndAddBrush()
      Initializes a PACurveMaker instance with allPoints as an argument to the factory method PACurveMaker.buildCurveMaker() and then fills in PACurveMaker instance variables.

    • makeBrushFromCurveMaker

      public AudioBrush makeBrushFromCurveMaker()
      Returns:

    • makeBrush

      public AudioBrush makeBrush(PACurveMaker curve, GestureGranularConfig.Builder config)

    • makeBrush

      public AudioBrush makeBrush(PACurveMaker curve, GestureGranularConfig.Builder config, GestureGranularConfigIO.InstrumentType instrumentType)
      End point for all makeBrush(...) calls, applies cues and special fx.
      Parameters:
      curve -
      config -
      instrumentType -
      Returns:

    • applyPresets

      public DeadBodyWorkFlow.CueResult applyPresets(GestureGranularConfig.Builder cfg, PACurveMaker curve)

    • isBrushInteractable

      boolean isBrushInteractable(AudioBrush b)

    • setActiveBrush

      void setActiveBrush(AudioBrush brush)

    • setActiveBrush

      void setActiveBrush(AudioBrush brush, int idx)

    • recomputeUIBaselinesFromActiveBrush

      void recomputeUIBaselinesFromActiveBrush()

    • drawBrushShapes

      public void drawBrushShapes()
      Iterates over brushShapesList and draws the brushstrokes stored in each PACurveMaker in the list.

    • drawBrushes

      public void drawBrushes(List<? extends AudioBrush> brushes, int readyColor, int hoverColor, int selectedColor)

    • getPathPoints

      ArrayList<processing.core.PVector> getPathPoints(AudioBrush b)

    • getScheduleForBrush

      public GestureSchedule getScheduleForBrush(AudioBrush b)
      Parameters:
      b - an AudioBrushLite instance
      Returns:
      GestureSchedule for the current pathMode of the brush

    • initBrushTransform

      void initBrushTransform(AudioBrush b)

    • updateAnimatedBrushes

      void updateAnimatedBrushes()

    • mouseInPoly

      public boolean mouseInPoly(ArrayList<processing.core.PVector> poly)
      Parameters:
      poly - a polygon described by an ArrayList of PVector
      Returns:
      true if the mouse is within the bounds of the polygon, false otherwise

    • pointInPoly

      public boolean pointInPoly(ArrayList<processing.core.PVector> poly, int x, int y)
      Parameters:
      poly - a polygon described by an ArrayList of PVector
      x - x-coordinate
      y - y-coordinate
      Returns:
      true if the mouse is within the bounds of the polygon, false otherwise

    • reset

      public void reset(boolean isClearCurves)
      Reinitializes audio and clears event lists. If isClearCurves is true, clears brushShapesList. There's no key command to trigger this, yet. TODO decide if you want a key command.
      Parameters:
      isClearCurves -

    • removeActiveBrush

      public void removeActiveBrush()
      Removes the current active PACurveMaker instance, flagged by a highlighted brush stroke, from brushShapesList, if there is one.

    • removeHoverBrush

      public void removeHoverBrush()
      Removes the current active PACurveMaker instance, flagged by a highlighted brush stroke, from brushShapesList, if there is one.

    • removeNewestBrush

      public void removeNewestBrush()
      Removes the newest PACurveMaker instance, shown as a brush stroke in the display, from brushShapesList.

    • removeOldestBrush

      public void removeOldestBrush()
      Removes the oldest brush in brushShapesList.

    • toggleBrushType

      AudioBrush toggleBrushType(AudioBrush brush)
      Convert a brush to the opposite type, GranularBrush to/from SamplerBrush, reusing their PACurveMaker and the GestureGranularConfig.Builder instances. This is a replacement operation: the old brush should be removed from its list immediately after conversion.
      Parameters:
      brush - AudioBrush to convert

    • toSamplerBrush

      SamplerBrush toSamplerBrush(AudioBrush brush)
      Convert a brush explicitly to SamplerBrush.

    • toGranularBrush

      GranularBrush toGranularBrush(AudioBrush brush)
      Convert a brush explicitly to GranularBrush.

    • replaceBrush

      void replaceBrush(AudioBrush oldBrush, AudioBrush newBrush, int oldIndex)
      Remove oldBrush from its current typed list, insert newBrush into the opposite typed list, and preserve hover/active state. oldIndex should be the index in the old brush's own list.

    • appendGranularBrush

      int appendGranularBrush(GranularBrush gb)
      Append a granular brush and return its new index.

    • appendSamplerBrush

      int appendSamplerBrush(SamplerBrush sb)
      Append a sampler brush and return its new index.

    • removeGranularBrush

      void removeGranularBrush(AudioBrush gb, int idx)
      Remove a granular brush using index when reliable, else by object.

    • removeSamplerBrush

      void removeSamplerBrush(AudioBrush sb, int idx)
      Remove a sampler brush using index when reliable, else by object.

    • normalizeConfigForSampler

      void normalizeConfigForSampler(GestureGranularConfig.Builder cfg)
      Normalize config values when converting to SamplerBrush. Keep most gesture/path information intact.

    • normalizeConfigForGranular

      void normalizeConfigForGranular(GestureGranularConfig.Builder cfg)
      Normalize config values when converting to GranularBrush. Keep most gesture/path information intact, but make a few granular-friendly adjustments.

    • toggleHoveredBrushType

      AudioBrush toggleHoveredBrushType()
      Toggle the currently hovered brush between SamplerBrush and GranularBrush.

    • toggleActiveBrushType

      AudioBrush toggleActiveBrushType()
      Toggle the currently active brush between SamplerBrush and GranularBrush.

    • syncDrawingModeToBrush

      void syncDrawingModeToBrush(AudioBrush brush)
      Change the current DrawingMode to suit the brush passed as an argument.
      Parameters:
      brush - an AudioBrush instance

    • scheduleSamplerBrushClick

      void scheduleSamplerBrushClick(SamplerBrush sb, int clickX, int clickY)

    • scheduleSamplerBrushClick

      void scheduleSamplerBrushClick(SamplerBrush sb, int clickX, int clickY, PAControlCurve gainCurve)

    • storeSamplerBrushEvents

      public void storeSamplerBrushEvents(GestureSchedule sched, GestureGranularConfig snap, int startTime, PAControlCurve gainCurve)

    • runSamplerBrushEvents

      public void runSamplerBrushEvents()
      Runs sampler brush events in the samplerTimeLocs list. TODO move audio events into a sample-accurate (or at least block-accurate) schedule

    • scheduleGranularBrushClick

      public void scheduleGranularBrushClick(GranularBrush gb, int clickX, int clickY)

    • scheduleGranularBrushClick

      public void scheduleGranularBrushClick(GranularBrush gb, int clickX, int clickY, PAControlCurve gainCurve)
      Schedules a response to a mouse click or hover + spacebar on a granular brush.
      Parameters:
      gb - a GranularBrush
      clickX - x-coordinate of point of activation
      clickY - y-coordinate of point of activation

    • storeGranularCurveTL

      public void storeGranularCurveTL(GestureSchedule sched, int startTime, boolean isGesture)
      Stores granular gesture time/location events in grainTimeLocs.
      Parameters:
      sched - a GestureSchedule, the times when things happen and where they happen
      startTime - time when a gesture starts
      isGesture - is the timing gesture-based or fixed? ignored, for now

    • runGrainEvents

      public void runGrainEvents()
      Tracks and runs TimedLocation events in the grainLocsArray list, which is associated with granular synthesis gestures.

    • runPointEvents

      public void runPointEvents()
      Tracks and runs TimedLocation events in the timeLocsArray list, which is associated with mouse clicks that trigger audio a the click point. TODO java.util.ConcurrentModificationException BUG

    • pointTimeLocsAddPoint

      public void pointTimeLocsAddPoint(TimedLocation tl)
      Adds a TimedLocation to the pointTimeLocs list.
      Parameters:
      tl - a TimedLocation

    • drawCircle

      public void drawCircle(int x, int y)
      Draws a circle at the location of an audio trigger (mouseDown event).
      Parameters:
      x - x coordinate of circle
      y - y coordinate of circle

    • getPApplet

      public processing.core.PApplet getPApplet()
      Specified by:
      getPApplet in interface PANetworkClientINF

    • getMapper

      public PixelAudioMapper getMapper()
      Specified by:
      getMapper in interface PANetworkClientINF

    • controlMsg

      public void controlMsg(String control, float val)
      Specified by:
      controlMsg in interface PANetworkClientINF

    • playSample

      public int playSample(int samplePos)
      Specified by:
      playSample in interface PANetworkClientINF

    • playPoints

      public void playPoints(ArrayList<processing.core.PVector> pts)
      Specified by:
      playPoints in interface PANetworkClientINF

    • createGUI

      public void createGUI()
      Create all the GUI controls.

    • createControlWindow

      public void createControlWindow()
      Create a separate window for the GUI control palette.

    • createControlPanel

      public void createControlPanel()
      Create the GUI control palette.

    • createCommentsField

      public void createCommentsField()

    • createControls

      public void createControls()
      Create all the controls in the control palette.

    • addControlsToPanel

      public void addControlsToPanel()
      Add the controls to the control palette.

    • winDraw

      public void winDraw(processing.core.PApplet appc, g4p_controls.GWinData data)

    • isGuiTyping

      boolean isGuiTyping()

    • winKey

      public void winKey(processing.core.PApplet appc, g4p_controls.GWinData data, processing.event.KeyEvent evt)

    • controlPanel_hit

      public void controlPanel_hit(g4p_controls.GPanel source, g4p_controls.GEvent event)

    • allOption_clicked

      public void allOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • rdpOption_clicked

      public void rdpOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • curveOption_clicked

      public void curveOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • rdpEpsilonSlider_changed

      public void rdpEpsilonSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • curvePointsSlider_changed

      public void curvePointsSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • gestureOption_clicked

      public void gestureOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • fixedOption_clicked

      public void fixedOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • burstSlider_changed

      public void burstSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • resampleSlider_changed

      public void resampleSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • durationSlider_changed

      public void durationSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • grainLengthSlider_changed

      public void grainLengthSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • hopLengthSlider_changed

      public void hopLengthSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • grainLengthField_changed

      public void grainLengthField_changed(g4p_controls.GTextField source, g4p_controls.GEvent event)

    • hopLengthField_changed

      public void hopLengthField_changed(g4p_controls.GTextField source, g4p_controls.GEvent event)

    • pitchShiftText_changed

      public void pitchShiftText_changed(g4p_controls.GTextField source, g4p_controls.GEvent event)

    • gainSlider_changed

      public void gainSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • linearWarpOption_clicked

      public void linearWarpOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • expWarpOption_clicked

      public void expWarpOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • squareRootOption_clicked

      public void squareRootOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • customWarpOption_clicked

      public void customWarpOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • warpSlider_changed

      public void warpSlider_changed(g4p_controls.GSlider source, g4p_controls.GEvent event)

    • arcLengthTimeOption_clicked

      public void arcLengthTimeOption_clicked(g4p_controls.GOption source, g4p_controls.GEvent event)

    • envelopeMenu_clicked

      public void envelopeMenu_clicked(g4p_controls.GDropList source, g4p_controls.GEvent event)

    • printGConfigStatus

      public void printGConfigStatus()

    • envPreset

      static ADSRParams envPreset(String name)
      Parameters:
      name - the name of the ADSRParams envelope to return
      Returns:
      the specified ADSRParams envelope

    • nearlyEqual

      static boolean nearlyEqual(float a, float b)

    • envEquals

      static boolean envEquals(ADSRParams a, ADSRParams b)

    • envNameFor

      String envNameFor(ADSRParams env)

    • envMenuIndex

      int envMenuIndex(String name)

    • formatEnv

      String formatEnv(ADSRParams env)

    • quantizeToStep

      public static int quantizeToStep(int value, int step)
      Quantize an integer to the nearest multiple of step.

    • syncGuiFromConfig

      void syncGuiFromConfig()
      Synchronize the control palette knobs to the current gConfig, probably because a brush was selected and made active.

    • syncEnvelopeMenu

      void syncEnvelopeMenu(ADSRParams env)

    • findCustomIndex

      int findCustomIndex()

    • clampInt

      static int clampInt(int v, int lo, int hi)

    • setControlsEnabled

      void setControlsEnabled()
      Determine which controls to enable, based on the drawing mode.

    • isEditable

      boolean isEditable()

    • resetConfigToDefaults

      void resetConfigToDefaults()

    • printGOptHints

      void printGOptHints(float alpha)
      Print suggested values for optimizing grain overlap for a brush.
      Parameters:
      alpha -

    • calcGranularOptHints

      public int calcGranularOptHints(String tag, int N, float Tms, int hopSamples, int grainLenSamples, float sr, List<processing.core.PVector> scheduledPoints, float targetSpacingPx, float wt, float ws, StringBuffer sb)
      Calculate optimal configuration settings for a granular brush.
      Returns:
      optimal number of samples if time duration is kept as is

    • fmt

      static String fmt(float v, int decimals)

    • initListener

      public void initListener()
      Sets up sample-accurate AudioListener called from the Minim audio processing loop. We use the samples() methods in the AudioListener interface to call our processAudioBlock() method. The audio samples don't concern us, just the regular interval over which they are processed: essentially, we have a timer that wakes up at a regular interval.