Hi Francois,

I am not sure I understand what is your problem, but when you create a [adc~] you will have two outlets, one for each channel. Same thing for the [dac~], which has two inlets. So from the separate outlets of the [adc~] you can do whatever you want with each channel individually before sending the result to the [dac~]. If you have other channel configurations, you can use these as follows: [dac~ 4] for instance will have one single inlet and will output the signal via channel 4, while [dac~ 1 3 4] will have three inlets for channels 1, 3 and 4, respectively.

Does that answer your question or am I misunderstanding you?

Cheers,
Gilberto

Hi,
I would like to share my plugin : Camomile.
Camomile is a dynamic plugin made with Juce that allows to load and control Pure Data patches inside a digital audio workstation.

Feature :

• Support for multiple plugin instances.
• Automatic creation of GUIs (toggle, slider and numbox) toggle, slider, radio, comment, numbox
• Automatic recognition of parameters (name, label, range, minimum, maximum, etc.)
• Up to 8 channels 16 channels
• Up to 32 parameters 64 parameters
• Support for MIDI in and out
• Support for play head position
• Support for BPM

This is a beta version, only available for Mac, but
The last version release is available for Linux, Mac and Windows.
I'll be happy to receive your feedback.
Further information on the wiki.
Cheers

They're like [mtof] and [ftom], but now the objects accept 2 parameters:

• the reference pitch for middle A (default value is 440)
• the number of tones (default value is 12)

So let's say you want your reference pitch to be 432, considered by some to be a more mellow frequency, you would write:

• [ntof 432]

and to split an octave into just 8 distinct tones instead of the most conventional 12, you'd write:

• [ntof 432 8]

You can change these values after instantiation by using messages:

• [ref $1(
  • changes the reference pitch
• [tet $1(
  • changes the number of tones (in equal temperament)

It also comes with two counter objects: [cupq], and [cupqb]

[cupq] has three inlets:

• left inlet decrements
• right inlet increments
• middle inlet changes the step size.

[cupqb] is similar, but it includes an atom box, allowing you to slide the current count. It has two inlets:

• first inlet receives [+ $1( and [- $1( messages
• second inlet controls the step size.

[cupq] and [cupqb] are .pd files, so there's actually more you can do with them than what I've specified here.

These files are also on my github page under pd-externals.

EDIT: My musical scale object [muse] now also takes advantage of the ref and tet messages. Its help file allows you to play around with these features. The files have now also been added to the zip.

ntof-fton.zip

Hi there,

As you saw in that video, the object [pfft~] is mainly a container (although it automatically takes care of block size, window type, etc. for you) and the magic actually happens when you use [fftin~] and [fftout~]. In Pd, we don't have a container object like that (although you can use a subpatch or abstraction of course) and the equivalents of [fftin~] and [fftout~] are [rfft~] and [rifft~].

I recreated that patch of the video here, have a look:

example of spectral gate.pd

Take care,
Gilberto

Just being a bit pedantic here:

I know that $0-sends won't work in messages

It's not that $0 doesn't work in messages, it's more that dollar signs have different functions when used with objects and messages. When using them with objects, $1, $2, $3, etc. are creation arguments of the object. In the case of an abstraction, you can call these creation arguments by using [f $1], [f $2], [f $3], etc. The [f $0] is a special case: $0 is a unique number generated for each subpatch and abstraction, so that you can have several instances of a same abstraction and yet have an automatic way of distinguishing between them (useful when creating local sends and receives or tables, among other things).

When it comes to messages, $1, $2, $3, etc. refer to the values of a list received by the message. For instance, if you send a message [0 1 1000( to [$1, $2 $3(, you are effectively attributing $1 -> 0, $2 -> 1 and $3 -> 1000. These are not creation arguments, but rather work as simple variables. This is the reason $0 makes no sense inside a message. On the other hand, if you must have the value [f $0] inside a message, you can do the following trick:

[loadbang]
|
[f $0]
|
[$1(

So that $1 gets substituted by the first value of a list arriving, in which case would consitute only of the single value $0.

Hope this helps,
Gilberto

Creates music scales using simple lists or by sending new pitches to individual notes. The more creation arguments there are, the more inlets there will be. It sends a frequency value through the 1st outlet and the unaltered midi value through the 2nd outlet.

• [muse 40 4 7]
  • Sending 0, 1, 2 returns 40, 44, 47 respectively.
  • The scale cycles through higher and lower octaves
    • 3, 4, 5 returns 52, 56, 59
    • -1, -2, -3 returns 35, 32, 28

functions:

• [list | l | d | x | i ..(
  • Takes a list of numbers and maps the values to the array.
  • Any non-numeric values are skipped over.
  • They're basically all the same function, with the differences being in their offsets and/or whether it should change the size of the scale implicitly based on list size.
    -- i is an implicit list, which changes the size of the scale based on the number of arguments specified.
    -- x is an explicit list, which means that it doesn't change the scale size because it's leaving that up to the user to change explicitly. This message is also good for changing the root note.
    -- list or l is the default list, and whether it interprets lists implicitly or explicitly is based on whether the toggle "exp" is set to 1 or 0. By default, lists are interpreted implicitly.
    -- d has an offset of 1. It's basically a short form of [list d ...( or, a list that skips the root note. Like a normal list, it also adheres to the "exp" toggle to determine whether it is implicit or explicit.

• [exp 1|0(
  • sets a boolean to determine whether or not scale size is implied in the size of lists sent.
  • if exp equals 1, scale size will not change, unless the list is preceded by i.
  • if exp equals 0, scale size will change, unless the list is preceded by x.

• [n $1(
  • sets the size of the scale.
    • the scale by default, with no creation arguments, is only 2 float values. This amount grows based on how many arguments are specified. but the array also resizes itself automatically to twice its original size whenever a size requested goes over the current maximum range.
    • the same doubling effect applies to lists with more arguments than the maximum scale size.
      -- [muse 40 2 4 5 7 9 11] has 7 floats worth of bytes reserved for the scale.
      -- upon receiving [n 16(, since 16 is greater than (7 x 2), scale is resized to hold 16 floats.
      -- upon receiving [n 17(, scale is resized to hold 32 floats. This doesn't mean the scale uses all 32 notes, but the space is now reserved if you ever decide to increase the scale size later.

• [set $2 $1(
  • scale is assigned the value $1 at index $2.
    -- [set 6 11( set the 6th interval to 11.

• [ref $1(
  • sets the reference pitch of middle A.
    -- default value is 440.

• [tet $1(
  • assign the number of tones in an octave.
    -- tones refer to how large a semi-tone needs to be in order to evenly disperse an octave into a specific amount of distinct pitches.

• [oct $1(
  • assign the number of notes in an octave.
    -- notes refer to the number of semi-tones that the scale should jump when going to the next or previous octave.

• [octet $1( / [ot $1(
  • assigns # of notes and # of tones simultaneously

• [peek label(
  • prints the current scale.
  • a label is optional.

• [ptr label(
  • prints the current size of the float pointer that your scale uses. It isn't necessarily the same size as the scale itself.

muse-chrd.zip

Edit: This post was originally written with Pd-extended 0.43 in mind. These days there is a nice little plugin called Deken that you can use to easily download and install most of the popular libraries in Pd. It comes bundled with recent versions of Pd-vanilla. You can still use namespaces to load up the objects for most libraries, but for some libraries like zexy that have all the objects bundled into a single file, you will still need to use [declare] to load it up.

Installing libraries and plug-ins isn't so obvious. This guide will hopefully clear up the process, and may even explain more than you need to know.

Recent changes

This first section is mainly for those upgrading to Pd-0.43 from previous versions. If you're new to Pd and are starting on 0.43, you can just skip this section and get on with loading libraries.

It use to be that installing a library was done by putting it wherever you wanted on your system and adding its path to the preferences. While this wasn't particularly difficult, it did have some problems. Recent efforts have been made to standardize this a bit so those problems can be avoided.

In Pd-extended 0.43, you can't add paths from within Pd any more like you used to. You can open the preferences and add a path, but it won't save it. This means that non-default libraries won't load on start-up any more; you have to load them from within the patch. While this sounds like a hassle, it does have the advantage that patches are much easier to share. You don't have to worry about others having different start-up settings than you. It also forces the patch to document what libraries are being used, so if an object isn't loading, you don't have to go on some crazy hunt to find out where it came from or what it's supposed to do.

Putting them in the right folder

To make sure Pd can easily find the library, you need to put them in the right folder. This is OS dependent. The following folders are your options (taken from here). I personally recommend putting them in the user-specific folders since they are likely easier to migrate when updating your OS.

Linux:

User-specific:
~/pd-externals

Global:
/usr/local/lib/pd-externals

Mac OSX

User-specific:
~/Library/Pd

Global:
/Library/Pd

Windows

User-specific:
%AppData%/Pd

Global:
%CommonProgramFiles%/Pd

Linux and OSX are pretty straight-forward. "~" means your home folder.

Windows is a bit trickier. %AppData% and %CommonProgramFiles% are environment variables that contain specific directories. What the exact directory is depends on which version of Windows you are on. You can find out what it is by opening up the command line and typing this:

echo %AppData%

You might end up with something like C:\Users\username\AppData\Roaming or C:\Documentes and Settings\username\Application Data. Also, to see it in the file browser, you might need to show hidden files. At any rate, once you find the directory, create a Pd folder if there isn't one, and put your library, objects, or plug-ins there.

Loading whole libraries

To load a library you have a few options. The one that works on both vanilla and extended is to use [declare -stdpath libraryname]. The libraryname is the name of the folder that all the objects/abstractions are in.

[declare] doesn't always work as expected in abstractions, though. In Pd-extended, you can also use [import], which works well in abstractions. I have found that sometimes it doesn't work with libraries of abstractions that don't have a meta file, though. But that can be fixed by just making one. Simply create an empty Pd patch and save it as libraryname-meta.pd in the library's folder. That's all the meta patch is.

A third option (also Pd-extended only) is to use [path]. This is new to Pd-extended 0.43 and works similarly to [declare]. I haven't needed it, yet. But it's there.

Once the library is loaded, you should be able to load an object or abstraction just by creating it by name.

Loading objects or abstractions using namespaces

While this method means a little more typing, it is also the safest, and it makes it easier to find out what objects are from which library. The way you do it is add the library name (i.e. the namespace) to the beginning of the object when you call it, like this:

[zexy/multiplex~] <-- load the [multiplex~] object from zexy
[cyclone/comb~] <-- load [comb~] from cyclone

You don't have to load the library with [import] or [declare] for this to work. You just call the object that way.

Why is this safest? Because it's possible for different libraries to have objects with the same name. For example, both cyclone and zexy have an object called [mean]. But they don't work exactly the same. zexy's takes a list, while cyclone's takes in a continuous stream. If you have both libraries loaded (and in Pd-extended, these two libraries happen to be loaded by default), you can't be sure which one you're getting if you just type [mean]. However, if you type [cyclone/mean], you know exactly which one you are getting.

Hi Everyone,
I've been having problems for a while with almost all of the external libraries not loading in Pd-extended. I have tried a couple of times to fix it but have not had success. I've read a couple of the other threads on this topic and i think maybe it is a problem with the org.puredata.pd.default.plist but i dont really know what is wrong.

here is what is in that file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>defeatrt</key>
<string>0</string>
<key>flags</key>
<string>-helppath ~/Library/Pd -helppath /Library/Pd</string>
<key>loadlib1</key>
<string>libdir</string>
<key>loadlib2</key>
<string>Gem</string>
<key>loadlib3</key>
<string>cyclone</string>
<key>loadlib4</key>
<string>zexy</string>
<key>loadlib5</key>
<string>creb</string>
<key>loadlib6</key>
<string>cxc</string>
<key>loadlib7</key>
<string>iemlib</string>
<key>loadlib8</key>
<string>list-abs</string>
<key>loadlib9</key>
<string>mapping</string>
<key>loadlib10</key>
<string>markex</string>
<key>loadlib11</key>
<string>maxlib</string>
<key>loadlib12</key>
<string>memento</string>
<key>loadlib13</key>
<string>mjlib</string>
<key>loadlib14</key>
<string>motex</string>
<key>loadlib15</key>
<string>oscx</string>
<key>loadlib16</key>
<string>pddp</string>
<key>loadlib17</key>
<string>pdogg</string>
<key>loadlib18</key>
<string>pixeltango</string>
<key>loadlib19</key>
<string>pmpd</string>
<key>loadlib20</key>
<string>rradical</string>
<key>loadlib21</key>
<string>sigpack</string>
<key>loadlib22</key>
<string>smlib</string>
<key>loadlib23</key>
<string>toxy</string>
<key>loadlib24</key>
<string>unauthorized</string>
<key>loadlib25</key>
<string>vbap</string>
<key>loadlib26</key>
<string>pan</string>
<key>loadlib27</key>
<string>freeverb</string>
<key>loadlib28</key>
<string>hcs</string>
<key>loadlib29</key>
<string>jmmmp</string>
<key>loadlib30</key>
<string>ext13</string>
<key>loadlib31</key>
<string>ggee</string>
<key>loadlib32</key>
<string>iem_anything</string>
<key>loadlib33</key>
<string>flib</string>
<key>loadlib34</key>
<string>ekext</string>
<key>loadlib35</key>
<string>flatspace</string>
<key>loadlib36</key>
<string>pdp</string>
<key>loadlib37</key>
<string>pidip</string>
<key>nloadlib</key>
<string>37</string>
<key>path1</key>
<string>/System/Library/Fonts</string>
<key>path2</key>
<string>/Library/Fonts</string>
<key>path3</key>
<string>~/Library/Fonts</string>
<key>path4</key>
<string>/usr/X11R6/lib/X11/fonts/TTF</string>
<key>path5</key>
<string>/System/Library/Frameworks/JavaVM.framework/Versions/1.5.0/Home/lib/fonts</string>
<key>npath</key>
<string>5</string>
</dict>

</plist>

===========

i have the path and startup settings set to the pd/contents/resources/exta folder. i tried copying all the libraries to someplace else and tried putting that in the path too, but it didnt work.

this has been driving me crazy for a while and i really need to fix it now!!! someone help pllleeeeaaaasseeee!!!!!!!

i make a lot of experimental/drone music with PD and i will send you a CD if you can help me! thanks.