pconvolve
Prev | Orchestra Opcodes and Operators | Next

## pconvolve

convolve — Convolution based on a uniformly partitioned overlap-save algorithm

## Description

Convolution based on a uniformly partitioned overlap-save algorithm. Compared to the convolve opcode, pconvolve has these benefits:

- small delay

- possible to run in real-time for shorter impulse files

- no pre-process analysis pass

- can often render faster than convolve

## Syntax

    ar1 [, ar2] [, ar3] [, ar4] pconvolve ain, ifilcod [, ipartitionsize, ichannel]

## Initialization

ifilcod -- integer or character-string denoting an impulse response soundfile. Multichannel files are supported, the file must have the same sample-rate as the orc. [Note: cvanal files cannot be used!] Keep in mind that longer files require more calculation time [and probably larger partition sizes and more latency]. At current processor speeds, files longer than a few seconds may not render in real-time.

ipartitionsize (optional, defaults to the output buffersize [-b]) -- the size in samples of each partition of the impulse file. This is the parameter that needs tweaking for best performance depending on the impulse file size. Generally, a small size means smaller latency but more computation time. If you specify a value that is not a power-of-2 the opcode will find the next power-of-2 greater and use that as the actual partition size.

ichannel (optional) -- which channel to use from the impulse response data file.

## Performance

ain -- input audio signal.

The overall latency of the opcode can be calculated as such [assuming ipartitionsize is a power of 2]

        ilatency = (ksmps < ipartitionsize ? ipartitionsize + ksmps : ipartitionsize)/sr

## Examples

Instrument 1 shows an example of real-time convolution.

Instrument 2 shows how to do file-based convolution with a 'look ahead' method to remove all delay.

| NOTE
You can download impulse response files from noisevault.com or replace the filenames with your own impulse files.

Here is an example of the pconvolve opcode. It uses the file pconvolve.csd.

Example 749. Example of the pconvolve opcode.

See the sections Real-time Audio and Command Line Flags for more information on using command line flags.

    <CsoundSynthesizer>
    <CsOptions>
    ; Select audio/midi flags here according to platform
    -odac  ;;;realtime audio out
    -iadc    ;;;uncomment -iadc if real audio input is needed too
    ; For Non-realtime ouput leave only the line below:
    ; -o pconvolve.wav -W ;;; for file output any platform
    </CsOptions>
    <CsInstruments>

    ; additions by Menno Knevel 2022

    sr = 44100
    ksmps = 32
    nchnls = 2
    nchnls_i = 1    ; assume only one mono signal for audio input!
    0dbfs  = 1

    instr   1

    kmix = .5                                   ; Wet/dry mix
    kvol  = .05*kmix                            ; volume level of reverb

    kmix = (kmix < 0 || kmix > 1 ? .5 : kmix)   ; do some safety checking
    kvol  = (kvol < 0 ? 0 : .5*kvol*kmix)       ; to make sure we the parameters a good

    ipartitionsize = p4                         ; size of each convolution partion
                                                ; for best performance, this parameter needs to be tweaked
    idel = (ksmps < ipartitionsize ? ipartitionsize + ksmps : ipartitionsize)/sr    ; calculate latency
    prints "\nConvolving with a latency of %f seconds\n", idel
    prints "***if no live input is given, nothing will sound...***\n\n"

    alive in                                    ; get live input (mono)
    awetl, awetr pconvolve kvol* (alive), "drumsSlp.wav", ipartitionsize

    adryl delay (1-kmix)*alive, idel            ; delay dry signal, to align it with the convoled sig
    adryr delay (1-kmix)*alive, idel
          outs adryl+awetl, adryr+awetr

    endin

    instr 2

    imix = 0.5                                  ; Wet/dry mix
    ivol = .05*imix                             ; volume level of reverb when wet/dry mix is changed, to avoid clipping

    ipartitionsize = 1024                       ; size of each convolution partion
    idel = (ksmps < ipartitionsize ? ipartitionsize + ksmps : ipartitionsize)/sr   ; latency of pconvolve opcode

    kcount  init    idel*kr
    ; since we are using a soundin [instead of in] we can do a kind of "look ahead"
    ; without output, creating zero-latency  by looping during one k-pass
    loop:
        asig soundin p4, 0
        awetl, awetr pconvolve ivol*(asig),"rv_stereo.wav", ipartitionsize
        adry delay  (1-imix)*asig,idel  ; Delay dry signal, to align it with
        kcount = kcount - 1
     if kcount > 0 kgoto loop
        outs awetl+adry, awetr+adry

    endin

    </CsInstruments>
    <CsScore>

    i 1 0 20 1024       ;play live for 20 seconds

    i 2 20 5 "fox.wav"
    i 2 25 5 "flute.aiff"
    e
    </CsScore>
    </CsoundSynthesizer>

## See also

Convolution and Morphing

## Credits

Author: Matt Ingalls
2004

Prev | Up | Next
pchtom | Home | pcount