Skip to content

pconvolve

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]])

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 of the pconvolve opcode.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<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