Packages

  • package root
    Definition Classes
    root
  • package de
    Definition Classes
    root
  • package sciss

    The interfaces are grouped into the following packages:

    Welcome to the Mellite API documentation.

    The interfaces are grouped into the following packages:

    The Lucre transactional object model:

    • de.sciss.lucre.stm is the base package for transactions, with things like Obj, Txn, Sys, and Cursor
    • de.sciss.lucre.artifact is the base package for file system artifacts, with classes Artifact and ArtifactLocation
    • de.sciss.lucre.expr is the base package for expression types such as IntObj, DoubleObj, etc.

    Other useful packages:

    • de.sciss.synth.io for reading and writing audio files
    • de.sciss.osc for general Open Sound Control interfaces
    Definition Classes
    de
  • package synth
    Definition Classes
    sciss
  • object Ops

    Importing the contents of this object adds imperative (side-effect) functions to resources such as synths, buses, buffers.

    Importing the contents of this object adds imperative (side-effect) functions to resources such as synths, buses, buffers. In general these reflect the OSC messages defined for each object, and send them straight to the server. For example, a Synth has function newMsg which returns an OSC message to instantiate the synth of the server. After importing Ops, you will be able to directly launch a synth using SynthDef.play or Synth.play. You will be able to directly allocate and read buffers, and so forth.

    The reason why these functions are separated from the rest of the API is to allow other frameworks such as SoundProcesses to avoid side-effects which they handle differently (e.g., using STM).

    Definition Classes
    synth
  • BufferConstructors
  • BufferOps
  • ControlBusOps
  • EnvOps
  • GroupConstructors
  • GroupOps
  • NodeOps
  • ServerOps
  • SynthConstructors
  • SynthDefConstructors
  • SynthDefOps
  • SynthOps
c

de.sciss.synth.Ops

BufferOps

implicit final class BufferOps extends AnyVal

Linear Supertypes
AnyVal, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. BufferOps
  2. AnyVal
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new BufferOps(b: Buffer)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  2. final def ##: Int
    Definition Classes
    Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
  4. def alloc(numFrames: Int, numChannels: Int = 1, completion: Optional[Packet] = None): Future[Unit]
  5. def allocRead(path: String, startFrame: Int = 0, numFrames: Int = -1, completion: Optional[Packet] = None): Future[Unit]
  6. def allocReadChannel(path: String, startFrame: Int = 0, numFrames: Int = -1, channels: Seq[Int], completion: Optional[Packet] = None): Future[Unit]
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. def cheby(amps: Seq[Float], normalize: Boolean = true, wavetable: Boolean = true, clear: Boolean = true): Future[Unit]

    Fills the buffer with a series of Chebyshev polynomials.

    Fills the buffer with a series of Chebyshev polynomials. The formula of these polynomials is

    cheby(n) = amplitude  * cos(n * acos(x))

    To eliminate a DC offset when used as a wave-shaper, the wavetable is offset so that the center value is zero.

    amps

    amplitudes for the harmonics. amplitudes for the harmonics. The first value specifies the amplitude for n = 1, the second float value specifies the amplitude for n = 2, and so on.

    normalize

    if set, the peak amplitude of the generated waveform is normalized to 1.0

    wavetable

    if set, the format of the waveform is chosen to be usable by specific UGens such as such as Shaper or Osc

    clear

    if set, the previous content is erased, otherwise the new waveform is added to the existing content

  9. def close(completion: Optional[Packet] = None): Unit
  10. def fill(data: FillRange*): Unit
  11. def fill(value: Double): Unit
  12. def free(completion: Optional[Packet] = None): Unit
  13. def gen(command: Command): Future[Unit]
  14. def get(indices: Int*): Future[IndexedSeq[Float]]
  15. def getClass(): Class[_ <: AnyVal]
    Definition Classes
    AnyVal → Any
  16. def getData(offset: Int = 0, num: Int = -1): Future[IndexedSeq[Float]]

    Retrieves the entire buffer contents.

    Retrieves the entire buffer contents. This is similar to getToFloatArray in sclang. If multiple packets must be sent due to the size, they will be scheduled strictly sequentially. This is safe but potentially slow for large buffers.

    offset

    offset into the buffer in samples; for multi-channel buffers to indicate a specific frame the frame index must be multiplied by the number of channels

    num

    the number of samples to get; for multi-channel buffers to indicate a specific number of frames, the number must be multiplied by the number of channels. The special value -1 means that all samples should be retrieved

  17. def getn(pairs: Range*): Future[IndexedSeq[Float]]

    Gets ranges of the buffer content and returns them as a future flattened collection.

  18. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  19. def play(loop: Boolean = false, amp: Double = 1.0, out: Int = 0): Synth
  20. def read(path: String, fileStartFrame: Int = 0, numFrames: Int = -1, bufStartFrame: Int = 0, leaveOpen: Boolean = false, completion: Optional[Packet] = None): Future[Unit]
  21. def readChannel(path: String, fileStartFrame: Int = 0, numFrames: Int = -1, bufStartFrame: Int = 0, leaveOpen: Boolean = false, channels: Seq[Int], completion: Optional[Packet] = None): Future[Unit]
  22. def set(pairs: FillValue*): Unit

    Sets the contents of the buffer by replacing individual sample values.

    Sets the contents of the buffer by replacing individual sample values. An error is thrown if any of the given offsets is out of range.

    pairs

    a list of modifications to the buffer contents, each element being a sample offset and the sample value. The sample offset ranges from zero to the number of samples in the buffer (exclusive), i.e. numChannels * numFrames. For instance, in a stereo-buffer, the offset for the right channel's fifth frame is (5-1) * 2 + 1 = 9.

  23. def setData(values: IndexedSeq[Float], offset: Int = 0): Future[Unit]

    Transmits a collection to fill the entire buffer contents.

    Transmits a collection to fill the entire buffer contents. This is similar to sendCollection in sclang, If multiple packets must be sent due to the size, they will be scheduled strictly sequentially. This is safe but potentially slow for large buffers.

    values

    the collection to copy into the buffer; values are assumed to be de-interleaved if the buffer has multiple channels.

    offset

    offset into the buffer in samples; for multi-channel buffers to indicate a specific frame the frame index must be multiplied by the number of channels

  24. def setn(pairs: (Int, IndexedSeq[Float])*): Unit

    Sets the contents of the buffer by replacing individual contiguous chunks of data.

    Sets the contents of the buffer by replacing individual contiguous chunks of data. An error is thrown if any of the given ranges lies outside the valid range of the entire buffer.

    pairs

    a list of modifications to the buffer contents, each element being a sample offset and a chunk of values. The data is channel-interleaved, e.g. for a stereo-buffer, the offset for the right channel's fifth frame is (5-1) * 2 + 1 = 9. Accordingly, values in the float-sequences are considered channel-interleaved, i.e. for a stereo buffer and an even offset, the first element of the sequence refers to frame offset / 2 of the left channel, the second element to frame offset / 2 of the right channel, followed by frame offset / 2 + 1 of the left channel, and so on.

  25. def setn(v: IndexedSeq[Float]): Unit

    Sets the entire contents of the buffer.

    Sets the entire contents of the buffer. An error is thrown if the number of given values does not match the number of samples in the buffer.

    v

    the new content of the buffer. the size of the sequence must be exactly the number of samples in the buffer, i.e. numChannels * numFrames. Values are channel-interleaved, that is for a stereo-buffer the first element specifies the value of the first frame of the left channel, the second element specifies the value of the first frame of the right channel, followed by the second frame of the left channel, etc.

  26. def sine1(partials: Seq[Float], normalize: Boolean = true, wavetable: Boolean = true, clear: Boolean = true): Future[Unit]

    Fills the buffer with a series of sine wave harmonics using specified amplitudes.

    Fills the buffer with a series of sine wave harmonics using specified amplitudes.

    partials

    amplitudes for the harmonics. The first value specifies the amplitude of the first partial, the second float value specifies the amplitude of the second partial, and so on.

    normalize

    if set, the peak amplitude of the generated waveform is normalized to 1.0

    wavetable

    if set, the format of the waveform is chosen to be usable by interpolating oscillators such as Osc or VOsc

    clear

    if set, the previous content is erased, otherwise the new waveform is added to the existing content

  27. def sine2(partials: Seq[(Float, Float)], normalize: Boolean = true, wavetable: Boolean = true, clear: Boolean = true): Future[Unit]

    Fills the buffer with a series of sine waves using specified frequencies and amplitudes.

    Fills the buffer with a series of sine waves using specified frequencies and amplitudes.

    partials

    pairs of frequencies and amplitudes for the partials. Frequencies are given as in cycles per buffer.

    normalize

    if set, the peak amplitude of the generated waveform is normalized to 1.0

    wavetable

    if set, the format of the waveform is chosen to be usable by interpolating oscillators such as Osc or VOsc

    clear

    if set, the previous content is erased, otherwise the new waveform is added to the existing content

  28. def sine3(partials: Seq[(Float, Float, Float)], normalize: Boolean = true, wavetable: Boolean = true, clear: Boolean = true): Future[Unit]

    Fills the buffer with a series of sine waves using specified frequencies, amplitudes, and phases.

    Fills the buffer with a series of sine waves using specified frequencies, amplitudes, and phases.

    partials

    triplets of frequencies, amplitudes and initial phases for the partials. Frequencies are given as in cycles per buffer. Phases are given in radians.

    normalize

    if set, the peak amplitude of the generated waveform is normalized to 1.0

    wavetable

    if set, the format of the waveform is chosen to be usable by interpolating oscillators such as Osc or VOsc

    clear

    if set, the previous content is erased, otherwise the new waveform is added to the existing content

  29. def toString(): String
    Definition Classes
    Any
  30. def write(path: String, fileType: AudioFileType = AudioFileType.AIFF, sampleFormat: SampleFormat = SampleFormat.Float, numFrames: Int = -1, startFrame: Int = 0, leaveOpen: Boolean = false, completion: Optional[Packet] = None): Future[Unit]
  31. def zero(completion: Optional[Packet] = None): Future[Unit]

Inherited from AnyVal

Inherited from Any

Ungrouped