HI,

a newbie, I am trying to install and use Pd 0.53.0 on a Fedora 35 machine.
I think I installed (from source) fine, but I do not get any sound.
I am not sure what I am supposed to check and do.

Some info on my install below.
Thanks for your help.

Below, I doubt line audio APIs: PortAudio ALSA OSS is how it should be, but I am not sure how to fix.

pd 0.53.0 is now configured 
Platform:             Linux
Debug build:          no
Universal build:      no
Localizations:        yes
Source directory:     .
Installation prefix:  /usr/local

Compiler:             gcc
CPPFLAGS:             -DNDEBUG  
CFLAGS:               -ffast-math -fno-finite-math-only -funroll-loops -fomit-frame-pointer -O3  -g -O2
LDFLAGS:               
INCLUDES:             
LIBS:                 -lpthread -ldl 

External extension:   pd_linux
External CFLAGS:      -fPIC
External LDFLAGS:     -Wl,--export-dynamic -fPIC

fftw:                 no
wish(tcl/tk):         wish
audio APIs:           PortAudio ALSA OSS 
midi APIs:            ALSA OSS 
libpd:                no 

 
$ ./pd -listdev
audio input devices:
0. USB Device 0x46d:0x825 (hardware)
1. USB Device 0x46d:0x825 (plug-in)
2. HDA Intel PCH (hardware)
3. HDA Intel PCH (plug-in)
4. HDA NVidia (hardware)
5. HDA NVidia (plug-in)
6. Trust PC Headset (hardware)
7. Trust PC Headset (plug-in)
audio output devices:
0. USB Device 0x46d:0x825 (hardware)
1. USB Device 0x46d:0x825 (plug-in)
2. HDA Intel PCH (hardware)
3. HDA Intel PCH (plug-in)
4. HDA NVidia (hardware)
5. HDA NVidia (plug-in)
6. Trust PC Headset (hardware)
7. Trust PC Headset (plug-in)
API number 1

MIDI input devices:
1. ALSA MIDI device #1
MIDI output devices:
1. ALSA MIDI device #1
priority 94 scheduling failed.```

If I try to set to something different from HDA Intel, I get
ALSA input error (snd_pcm_open): Device or resource busy
ALSA output error (snd_pcm_open): No such file or directory
`

Hi,

I need to be able to convert a value within a given range to an exponential value within the same range. I made an abstraction "autoscale" which remap the highest and lowest received values to a given range.

If incoming is 0.3 and the lowest value so far been 0.2, the highest so far has been 1.2, and the range is set to 3 and 7 the output will be 4.

I would like to be able modify the output value to an exponential or logarithmic curve where you can set the curve steepness.

What options would there be to solve this? Could I have a function within an expression object? Or use an array? Please show me.

Once I got that going I need to be able to set the curve so that a given value will end up as the exact half of the scaled range. Using the values in the example above incoming value 0.3 should then output 5 after the exponential curve has been set.

autosclr.pd

Cheers!

One of the very early lessons that I teach in my interactive multimedia class is range mapping, where I derive the formulas and then leave them with ready-to-use patch structures for them.

1. If it's based on incoming data, first normalize (0 to 1, or -1 to +1, range). If you're generating a control signal, generate a normal range (e.g. [phasor~] is already 0 to 1).

2. For both linear and exponential mapping, there's a low value lo and a high value hi. (Or, if the normalized range is bipolar -1 to +1, a center value instead of lo.)

3. The "width" of the range is: linear hi - lo, exponential hi / lo.

4. Apply the width to the control signal by: linear, multiplying ((hi - lo) * signal); exponential, raising to the power of the control signal = (hi / lo) ** signal.

5. Then (linear) add the lo or center; (exponential) multiply by the lo or center.

One way to remember this is that the exponential formula "promotes" operators to the "next level up": + --> *, - --> /, * --> power-of (and / --> log, but that would only be needed for normalizing arbitrary exponential data from an external source). So if you know the linear formula and the operator-promotion rule, then you have everything.

• linear: (width * signal) + lo
• exponential: (width ** signal) * lo

(Then the "super-exponential" that bocanegra was hypothesizing would exponentiate twice: ((width ** signal) ** signal) * lo = (width ** (signal * signal)) * lo.)

0723-triple-mapping-demo.pd

[mtof~] is a great shortcut, of course, but -- I drill this pretty hard with my students because if you understand this, then you can map any values onto any range, not only MIDI note numbers. IMO this is basic vocabulary -- you'll get much further with, say, western music theory if you know what is a major triad, and you can go much further with electronic music programming if you learn how to map numeric ranges.

hjh

I've modified some abstractions created by @60hz for prototyping fast with ofelia (BTW, thanks a million for your abstractions they're great! And of course a million thanks to @cuinjune for creating Ofelia!). Things seem to work OK, but there's this happening. I have the following patch (I've changed the names from [gl.draw] to [ofelia.draw] for this and other abstractions)

[ofelia.draw]
|
[ofelia.cube]

and I see a white cube in the Ofelia window. Then I make the following connections:

[ofelia.draw]
|
[ofelia.movie]
|
[ofelia.cube]

and I get a video playing in the same cube. Till now everything is fine. But if I go back to the first patch, I don't get a white cube anymore but a still from the video file from [ofelia.movie]. Here are the scripts of the abstractions (almost identical to @60hz abstractions):
[ofelia.draw] (I'm returning ofColor because I want to have all abstractions output pointers and not bangs, maybe there's a better solution for this):

ofelia d draw$0;
local c = ofCanvas(this);
local args = c:getArgs();
local depth = true;
local screenwidth;
local screenheigh;
local widthHeigh;
;
function M.new();
  if args[2] == nil then depth = true;
  else;
  M.depth(args[2]);
  end;
  if ofWindow.exists then;
  screenwidth = ofGetWidth();
  screenheight = ofGetHeight();
  end;
end;
;
function M.screensize(list);
  screenwidth, screenheight = list[1], list[2];
end;
;
function M.depth(string);
  if string == "3d" then;
  depth = true;
  else;
  depth = false;
  end;
end;
function M.bang();
  ofSetDepthTest(depth);
  ofTranslate(screenwidth*0.5, screenheight*0.5);
  return ofColor(255, 255, 255);
end;

[ofelia.movie]:

ofelia d -c17 videoplayer-$0;
local canvas = ofCanvas(this);
local args = canvas:getArgs();
local videoplayer = ofVideoPlayer();
local filename, start, loop = args[1], args[2], args[3];
local loaded = 0;
;
function M.new();
  ofWindow.addListener("setup", this);
  if args[1] == nil then print("No file found");
  else M.open(filename);
  end;
  if args[2] == 1 then M.play();
  end;
  if args[3] == nil then loop = 0;
  end;
end;
;
function M.free();
  ofWindow.removeListener("setup", this);
end;
;
function M.setup();
  M.open(filename);
end;
;
function M.open(string);
  if ofWindow.exists then;
    videoplayer:close();
    videoplayer:load(string);
    if (videoplayer:isLoaded()) then;
    print("loaded " .. string);
    videoplayer:update();
    end;
  end;
end;
function M.url(string);
  if ofWindow.exists then;
    videoplayer:close();
    videoplayer:load(string);
    if (videoplayer:isLoaded()) then;
      print("loaded " .. string);
      videoplayer:update();
    end;
  end;
end;
function M.play() videoplayer:play() end;
function M.stop() videoplayer:stop() end;
function M.pause() videoplayer:setPaused(true) end;
function M.speed(float) videoplayer:setSpeed(float) end;
function M.frame(float) videoplayer:setFrame(float) end;
function M.volume(float) videoplayer:setVolume(float) end;
function M.loop(float);
  if float == 0 then videoplayer:setLoopState(OF_LOOP_NONE);
  elseif float == 1 then videoplayer:setLoopState(OF_LOOP_NORMAL);
  elseif float == 2 then videoplayer:setLoopState(OF_LOOP_PALINDROME);
  end;
end;
function M.get()
  return ofTable (videoplayer, videoplayer:isLoaded(), videoplayer:isPlaying(), videoplayer:getCurrentFrame(), videoplayer:getTotalNumFrames(), videoplayer:getWidth(), videoplayer:getHeight());
end;
;
function M.pointer(p);
  videoplayer:update();
  videoplayer:bind();
  return videoplayer;
end;
function M.bang();
  videoplayer:update();
  videoplayer:bind();
  return videoplayer;
end;

Inside [ofelia.movie] there's this patch:

[ofelia d movie_script] <- this is the ofelia object that loads the script above
|
[t a a]
|    |
|    [outlet]
|
[ofelia d videoplayer_unbind;] <- this is one object
[function M.pointer(p);      ]
[p:unbind;                   ]
[end;                        ]

and this is [ofelia.cube]:

ofelia d $0-box;
local c = ofCanvas(this);
local args = c:getArgs();
local width, height, depth, resw, resh, resd, drawmode, strokeweight = args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8];
local position, orientation, scale = ofVec3f(0, 0, 0), ofVec3f(0, 0, 0), ofVec3f(1, 1, 1);
;
function M.new();
  ofWindow.addListener("setup", this);
  if args[1] == nil then width = 100 end;
  if args[2] == nil then height = 100 end;
  if args[3] == nil then depth = 100 end;
  if args[4] == nil then resw = 5 end;
  if args[5] == nil then resh = 5 end;
  if args[6] == nil then resd = 5 end;
  if args[7] == nil then drawmode = "fill" end;
  if args[8] == nil then strokeweight = 1 end;
  M.setup();
end;
;
function M.free();
  ofWindow.removeListener("setup", this)
end;
;
function M.setup();
  box$0 = ofBoxPrimitive();
end;
;
function M.resw(float) resw = float end;
function M.resh(float) resh = float end;
function M.resd(float) resd = float end;
function M.width(float) width = float end;
function M.height(float) height = float end;
function M.depth(float) depth = float end;
function M.draw(string) drawmode = string end;
function M.stroke(float) strokeweight = float end;
function M.position(list) position = ofVec3f(list[1], list[2], list[3]) end;
function M.orientation(list) orientation = ofVec3f(list[1], list[2], list[3]) end;
function M.scale(list) scale = ofVec3f(list[1], list[2], list[3]) end;
;
function M.pointer(p);
  ofSetLineWidth(strokeweight);
  box$0:setPosition (position:vec3());
  box$0:setOrientation (orientation:vec3());
  box$0:setScale (scale:vec3());
  box$0:set(width, height, depth, math.abs(resw), math.abs(resh), math.abs(resd));
  if drawmode == "fill" then box$0:drawFaces() end;
  if drawmode == "point" then box$0:drawVertices() end;
  if drawmode == "line" then box$0:drawWireframe() end;
  return p;
end;
function M.bang();
  ofSetLineWidth(strokeweight);
  box$0:setPosition (position:vec3());
  box$0:setOrientation (orientation:vec3());
  box$0:setScale (scale:vec3());
  box$0:set(width, height, depth, math.abs(resw), math.abs(resh), math.abs(resd));
  if drawmode == "fill" then box$0:drawFaces() end;
  if drawmode == "point" then box$0:drawVertices() end;
  if drawmode == "line" then box$0:drawWireframe() end;
  return anything;
end;

This is a bit too much information but I think it's necessary if anyone can help. There's probably stuff I'm ignorant of. @cuinjune any hints?

I finished the Ofelia / Lua Markov Generator abstraction / patch.
The markov generator is part of two patches but can easily be used as an abstraction.
I want to use it for pattern variations of a sequencer for example.
It just needs a Pure Data list as input and outputs a markov chain of variable order and length.
Or draw into the array and submit it to the markov generator.
The first patch is an experiment trying to create interesting sounds with the markov algorithm.
In addition I used the variable Delay from the Pure Data help files:
LuaMarkovGeneratorSynthesizer.pd

The second patch creates markov chains at audio rate, it is quite cpu heavy but works until the 10th markov order.
It is quite noisy but I was courius how it will sound:
LuaMarkovGeneratorAudioRate.pd

And here is the Lua code.
The core of the code is adapted from this python code: https://eli.thegreenplace.net/2018/elegant-python-code-for-a-markov-chain-text-generator/
A few things that I do not really understand yet, but finally it works without errors (it was not easy sometimes ):

-- LUA MARKOV GENERATOR;
function ofelia.list(fv);
;
math.randomseed(os.time()- os.clock() * 1000);
;
print("LUA MARKOV GENERATOR");
local markovOrder = fv[1];
print("Markov Order: ", math.floor(markovOrder));
;
-- make dictionary;
;
local function defaultdict(default_value_factory);
;
local t = {};
local metatable = {};
metatable.__index = function(t, key);
if not rawget(t, key) then;
rawset(t, key, default_value_factory(key));
end;
return rawget(t, key);
end;
return setmetatable(t, metatable);
end;
;
-- make markov matrix;
;
local model = defaultdict(function() return {} end);
local data = {};
for i = 1, #ofelia.markovInputList do;
data[i] = ofelia.markovInputList[i];
end;
print("Data Size: ", #ofelia.markovInputList);
for i = 1, markovOrder do;
table.insert(data, data[i]);
end;
for i = 1, #data - markovOrder do;
local state = table.concat({table.unpack(data, i, i + markovOrder - 1)}, "-");
local next = table.unpack(data, i + markovOrder, i + markovOrder);
model[state][next] = (model[state][next] or 0)+1;
end;
;
-- make tables from dict;
;
local keyTbl = {};
local nexTbl = {};
local prbTbl = {};
for key, value in pairs(model) do;
for k, v in pairs(value) do;
table.insert(keyTbl, key);
table.insert(nexTbl, k);
table.insert(prbTbl, v);
end;
end;
;
print("Key: ", table.unpack(keyTbl));
print("Nex: ", table.unpack(nexTbl));
print("Prb: ", table.unpack(prbTbl));
;
print("Make a Markov Chain...");
;
function ofelia.markovChain();
;
-- make start key;
;
local startKey = {};
if ofelia.randomStart == 1 then;
local randomKey = math.random(#keyTbl);
startKey = randomKey;
else;
startKey = 1;
end;
;
local markovString = keyTbl[startKey];
local out = {};
for match in string.gmatch(keyTbl[startKey], "[^-]+") do;
table.insert(out, match);
end;
;
-- make markov chain;
;
for i = 1, ofelia.markovChainLength do;
;
-- weighted random choices;
;
local choices = {};
local weights = {};
for j = 1, #keyTbl do;
if markovString == keyTbl[j] then;
table.insert(choices, nexTbl[j]);
table.insert(weights, prbTbl[j]);
end;
end;
;
-- print ("choices:", table.unpack(choices));
-- print ("weights:", table.unpack(weights));
;
local totalWeight = 0;
for _, weight in pairs(weights) do;
totalWeight = totalWeight + weight;
end;
rand = math.random() * totalWeight;
local choice = nil;
for i, weight in pairs(weights) do;
if rand < weight then;
choice = choices[i];
break;
else;
rand = rand - weight;
end;
end;
;
if math.type(choice) == "integer" then;
choice = choice * (1.0);
end;
;
table.insert(out, choice);
local lastStep = {table.unpack(out, #out - (markovOrder-1), #out)};
markovString = table.concat(lastStep, "-");
end;
;
return {table.unpack(out, markovOrder + 1, #out)};
end;
end;
;

i build a lua markov generator inspired from this python code with the idea to use it with pure data / ofelia: https://eli.thegreenplace.net/2018/elegant-python-code-for-a-markov-chain-text-generator/
finally the code works fine with the eclipse lua ide or with this ide https://studio.zerobrane.com/, but somehow not yet with pure data / ofelia.
here is the (not yet working) patch: ofelia_markov.pd
and here the lua code: markov_pd.lua

math.randomseed(os.time()- os.clock() * 1000);
-- make dictionary;
function defaultdict(default_value_factory);
local t = {};
local metatable = {};
metatable.__index = function(t, key);
if not rawget(t, key) then;
rawset(t, key, default_value_factory(key));
end;
return rawget(t, key);
end;
return setmetatable(t, metatable);
end;
;
;
-- make markov matrix;
print('Learning model...')
;
STATE_LEN = 3;
print ("markov order: " , STATE_LEN) 
model = defaultdict(function() return {} end)
data = "00001111010100700111101010000005000700111111177111111";
datasize = #data;
print("data: ", data);
print("datasize: ", #data);
data = data .. data:sub(1, STATE_LEN);
print("altered data: ", data);
print("altered datasize: ", #data);
for i = 1, (#data - STATE_LEN) do;
state = data:sub(i, i + STATE_LEN-1);
-- print("state: ", state)    
local next = data:sub(i + STATE_LEN, i + STATE_LEN);
-- print("next: ", next);
model[state][next] = (model[state][next] or 0)+1;
end;
;
;
-- make markov chain;
print('Sampling...');
;
local keyTbl = {};
local nexTbl = {};
local prbTbl = {};
for key, value in pairs(model) do;
for k, v in pairs(value) do;
table.insert(keyTbl, key);
table.insert(nexTbl, k);
table.insert(prbTbl, v);
end;
end;
print ("keyTbl: ", table.unpack(keyTbl));
print ("nexTbl: ", table.unpack(nexTbl));
print ("prbTbl: ", table.unpack(prbTbl));
;
;
-- make random key;
local randomKey = keyTbl[math.random(#keyTbl)];
state = randomKey;
print("RandomKey: ", randomKey);
;
-- make table from random key;
local str = state;
local stateTable = {};
for i = 1, #str do;
stateTable[i] = str:sub(i, i);
end;
;
out = stateTable;
print ("random key as table: ", table.unpack(out));
;
-- make markov chain;
for i = 1, datasize do;
;
-- weighted random choices;
local choices = {};
local weights = {};
for j = 1, #keyTbl do;
if state == keyTbl[j] then;
table.insert(choices, nexTbl[j]);
table.insert(weights, prbTbl[j]);        
end;  
end;
-- print ("choices:",table.unpack(choices));
-- print ("weights:",table.unpack(weights));
;
local totalWeight = 0;
for _, weight in pairs(weights) do;
totalWeight = totalWeight + weight;
end;
rand = math.random() * totalWeight;     
local choice = nil;
for i, weight in pairs(weights) do;
if rand < weight then;       
choice = choices[i];
choice = choice:sub(1,1);
break;
else;
rand = rand - weight;
end;
end;  
;
table.insert(out, choice); 
state = string.sub(state, 2, #state) .. out[#out];
-- print("choice", choice);
-- print ("state", state);
end;    
;
print("markov chain: ", table.concat(out));

somehow pure data / ofelia interprets the nexTbl values as a functions while they are strings?
this is part of what the pure data console prints: nexTbl: function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30 function: 0000000003B9BF30
ofelia: [string "package.preload['#d41b70'] = nil package.load..."]:93: attempt to index a function value (local 'choice')

and this ist the output from the lua ide:

Program 'lua.exe' started in 'C:\Users\Jonat\Downloads\ZeroBraneStudio\myprograms' (pid: 220).
Learning model...
markov order:   1
data:   00001111010100700111101010000005000700111111177111111
datasize:   53
altered data:   000011110101007001111010100000050007001111111771111110
altered datasize:   54
Sampling...
keyTbl:     5   7   7   7   1   1   1   0   0   0   0
nexTbl:     0   0   1   7   7   1   0   5   7   1   0
prbTbl:     1   2   1   1   1   17  7   1   2   7   13
RandomKey:  1
random key as table:    1
markov chain:   111111000077701111100070001100000001100017011171111117
Program completed in 0.06 seconds (pid: 220).

I have an abstraction that builds a system exclusive parameter change message. I pass 3 arguments to the abstraction and it builds a system exclusive message from the 3 arguments and a value sent to the abstraction inlet from a slider.

One of the arguments corresponds to the source (audio channel) in a k1 hardware synthesizer. The decimal value of the source that goes into the sysex message is 0,2,4, or 6. But for ease of use I want to pass 1,2,3,4 as the value of the source argument to the abstraction, then have math convert that 1-4 value into the even numbers 0 - 6.

Here is a screen shot of the abstraction (k1sx) in the main patch with 3 arguments, 0, 41, 1 (channel number, parameter number, source number).

The abstraction should generate a midi message with the source number converted from 1 to 0 (1 - 1 * 2).

Here is a screen shot of my attempt to do this with an argument within the abstraction, which did not work...

Is there a way that I can take the $3 argument, subtract 1 multiply by 2 and then place this new value as the 2nd to the last value in the message box near the bottom of the patch?

Not being a math-guy, I sometimes struggle with math-stuff. Most of the time I got a "feeling" for the logic behind it or the timing and such - but how to address math-stuff really? Or let's call it "advanced programming stuff"... What's the easiest way to do a certain task? Simple tasks sometimes - but how?!

So, every now and then, I have to come up with some "math-hacks". Using only the simplest objects. And sometimes I end up pretty amazed by some little things. Like: Tasks I always tend to use a bunch of objects, I 'm suddenly able to do with one object only. Just some little, tiny alteration - and done! Do you know that feeling?

How about start a series of those little, elegant eureka-moments?
It doesn't have to be about "math" - I just mean: personal, little tweaks that let you simplify certain tasks in an elegant way.

Add to the collection Share your most simple, beautiful and elegant little eureka-thingies. We sure could learn a lot from each other. Finding those things within a big patch though is hard, so I suggest make the patch only about that one thing and maybe add a screenshot too, as these things should be so simple, that it's obvious by only looking at it... What maybe is obvious for one is big news for an other, right?

Let me start with one, and you immediately see what I mean:
I call it "if getting smaller/bigger do..." - and you maybe figured that one out already - I only just did...

Have a good time!
Marco

if_getting_smaller_bigger_do.pd

@Jona Technically, you can do everything that [ofEditMesh3dVertex] can do using [ofGetMesh3dVertex] and "fill". But if you use [ofEditMesh3dVertex], you can directly apply various math operations to its internal data which can be more convenient(and sometimes more efficient) than having to use [ofGetMesh3dVertex], [ofExpr] and "fill".

[ofEditMesh3dVertex] has same functionality as [ofEditVec3f] because mesh3d's vertices are made of vec3f data type. These editor objects can be useful for handling properties of 2d/3d object such as position, velocity or acceleration.

You can read the OF documentation about this. http://openframeworks.cc/documentation/math/ofVec3f/
Also, you can check examples from ofelia/examples/vectors directory.

That simplified the math very well, even found a little error in the math, but fixed it now. I am however experiencing an odd error, if I load a song and start playing it, it only plays on certain gain levels, plus it only seems as if it's playing on every 2nd tick of the bandwith and center frequency slider. I find this behaviour odd, as I at current points is pretty sure the math is correct, so maybe it's a PD thing I missed? Just wanted to check in, if there's something you might know regarding this.
You can test it for yourself with the fixed math:
eq.pd