carmel riboch

Hello I try to find the best way to make any audio file into text

I tried to install the aka.listen object but its just not working (I guess its not working on new Mac computers) 

eventually the patch need to get an audio file (everyone of them unnecessarily human speech)

Hello I try to find the best way to make any audio file into text
I tried to install the aka.listen object but its just not working (I guess its not working on new Mac computers) 
eventually the patch need to get an audio file (everyone of them unnecessarily human speech)
and write it as a text 

Hello I try to find the best way to make any audio file into text
I tried to install the aka.listen object but its just not working (I guess

speech-to-text-1

Speech To Text

Gregory Taylor

The first half of the title says it all - this is the first in a series of articles about getting used to the 

 patching environment if you're a beginner - and yes, I mean 

. This series of articles aims to help you become comfortable with the 

 object and the approaches you might take to do interesting work. I'm not going to be talking about what is necessarily the most clever way or the most efficient way to do something. In my experience, clever solutions often leave beginners feeling uncomfortable. I am also solidly with my friend Perry Cook’s advice on designing new musical instruments found in 

Working with Abstractions, Debugging, and Signal-Rate Processing

This will also be a little different kind of tutorial because I’m starting by asking a few questions. In the course of talks with beginner Max users that are interested in learning 

, there are some common things I’ve encountered repeatedly.

For example, you may have noticed some odd things the first time you opened someone else’s 

These are sources of real anxiety since so many other things look the same as Max. Another goal in this series is to work a kind of 

 Anxiety Top Ten that seeks to explain the scary or different things and why they are the way they are. I also hope to provide examples of how we solve certain kinds of problems in the Gen environment in light of those differences. There may not be 10 top items, but I think you can get the point.

 environment is fun to mess around with in the same way that MSP is: you crack open a 

 object, add a few operators, and you can hack audio programming while you listen to the results. While it’s always fun to learn and engage with new things, our time is limited, so there’s nothing wrong with wanting to know upfront why it’s useful to learn a new thing. Here are some areas where people with whom I’ve interacted have found learning 

image.png

If you’re interested in any of the five things I’ve listed above, then you’re officially a potential 

 user. So let’s move on to the next bit: Overcoming 

Over the course of several years, I’ve come to see a particular kind of problem that working in the Gen environment presents: When your beginner self adds a 

 object to your patch and double-clicks on it to open it, you find yourself in a window that 

. It's got a different-looking toolbar. You’re not sure how to get help, or how to discover what the objects in a 

 patch do, and even if you figure out things are different, it's hard to know 

 they're different. The sum total of those differences can seem overwhelming upon first encounter.

In this tutorial series, we are going to look at some things I’ve found help new users make sense of the new 

world. They’re small things - often simpler than the smallest of example patches - that will assist you in your transition to having fun with 

Sigmund Freud describes the purpose of psychotherapy as "the conversion of hysterical misery into common unhappiness." I think that anyone who wants to teach beginners has a kind of common goal - converting hysterical anxiety to common uncertainty. Uncertainty over solving a specific problem is much simpler to deal with than being generally bewildered by the environment you're trying to use to solve the problem. Here begins an ongoing list of entries from my official 

Let’s start at the begining. To start patching in 

 object to the patch. When you Command-double-click (or Control-double-click on Windows) to open a 

 patcher window, you’ll see something that looks like a Max patcher window, but is a little different. Never fear - as a beginner, there are really only a couple of things you need to care about as you begin.

The first one’s obvious: the locking/unlocking the patcher window is just like Max - a lock in the lower left-hand corner of the patcher window.

The upper toolbar reflects the fact that the operators available to you don’t include any UI objects (

 patchers don’t have them), and the right-hand toolbar will also look familiar, with the exception of the C (Code) icon - a part of the 

 patcher window that we'll look at in just a minute. The patcher window differences from Max are minimal and easy to get used to - locking/unlocking your patch and using the Code window are all you’ll really need to know, for now.

One way in which the Gen patching environment differs from Max has to do with its 

 patcher window, option-clicking (Macintosh) or alt-clicking (Windows) on any operator will display a reference-like description of the object in a scrolling pop-up window. Since there is a smaller number of 

 operators, and those operators tend to be more low-level than their Max relatives, the Gen environment uses clear and concise text files rather than more complex help files (and, unlike Max help files, you'll find examples available as files that are distributed with Gen.

pasted image

: To open a full listing of all general objects in the standard Max Documentation Browser, click on the information icon (that little circle with the “i” in it) in the pop-up window. Your selection will appear as the top line of the displayed listing.

 operator will display a Max assistance bubble with information about the inlet or outlet.

 patcher window, you’ll notice that a new icon is displayed on the patcher window’s right border – the Code tab. Clicking on the Code tab’s icon will display the actual code that Gen operators use (called GenExpr) to produce the machine code compiled as you work.

 patch will highlight the code associated with that operator. As you patch, you can watch the code change in real time as your changes are recompiled in the background. This window is really useful for things like discovering what the default state of an operator is, and when working with the 

 patcher window behaves similarly to the Reference icon in a Max patcher window: Displaying this window and clicking on an operator displays information about inlets and outlets and attributes associated with an operator.

That’s how you can navigate and figure things out in the 

The Gen environment consists of a smaller set of objects than you’re accustomed to working with in the MSP environment. The operators in the set you’ll work with are inspired by Max/MSP objects, and they’ll often have the same name as their MSP counterparts. In general, the easiest way to think of the 

 environment is that most low-level MSP object equivalents exist, and the 

 operators will have more streamlined functionality. The helpfiles in the 

 environment are textual rather than oriented toward a variety of uses (when it comes to working with buffers, things are a little different, and we’ll talk about that in detail in a later tutorial).

If you don’t find what you’re looking for in that list of Gen operators The 

 examples folder contains many examples of how the Gen operator set can be used to create patchers that closely resemble the higher-level functionality of other MSP objects. In coming installments, we'll be looking at strategies you can use to extend the usefulness of 

 of this tutorial series, we'll work on your 

 anxieties by looking at some of the similarities and differences in the Max and Gen patching environments. Until then, open the 

The first half of the title says it all - this is the first in a series of articles about getting used to the gen~ patching environment if you're a beginner - and yes, I mean beginners. This series of articles aims to help you become comfortable with the gen~ object and the approaches you might take to do interesting work. I'm not going to be talking about what is necessarily the most clever way or the most efficient way to do something. In my experience, clever solutions often leave beginners feeling uncomfortable. I am also solidly with my friend Perry Cook’s advice on designing new musical instruments found in his 2001 NIME keynote address on the subject: 

All the tutorials in this series: Part 1, Part 2, Part 3, Part 4, Part 5, Part 6, Part 7 
Follow-up video tutorials: Working with Abstractions, Debugging, and Signal-Rate Processing

This will also be a little different kind of tutorial because I’m starting by asking a few questions. In the course of talks with beginner Max users that are interested in learning gen~, there are some common things I’ve encountered repeatedly.

New users are curious not only about what gen~ is but what it is that’s special about it and why they might want to invest the time to learn it. While it’s always fun to learn new things - and learning to work with gen~ is worth the time, I think - you might want to know what real practical advantages it offers.

It’s also the case that there’s a kind of anxiety associated with encountering gen~ for the first time. It’s like working with Max/MSP in some ways (there’s a patcher window that you add things to and connect to make a patch that does something) and unfamiliar in some other ways. The balance between similar and different can be unnerving when you are just starting. 

For example, you may have noticed some odd things the first time you opened someone else’s gen~ patchers:

Some operators have names you recognize, but they're missing the tilde (~) you associate with MSP audio-rate objects. There are no tildes in Gen operator names because everything in a gen~ patcher is running at single sample rate. They are all equal. 

When you start adding operators and paying attention to autocompletion, it becomes clear that the set of operators you have to work with isn't exactly like MSP objects. However, some gen~ operators look and act very much like their MSP counterparts. How do you find out what’s what?

At times, even objects you think you recognize look different inside Gen - operators inside of a gen~ patcher window may have other numbers of inlets than their Max equivalent. From time to time, you may even see two identical operators with the same name and different numbers of inlets.

These are sources of real anxiety since so many other things look the same as Max. Another goal in this series is to work a kind of gen~ Anxiety Top Ten that seeks to explain the scary or different things and why they are the way they are. I also hope to provide examples of how we solve certain kinds of problems in the Gen environment in light of those differences. There may not be 10 top items, but I think you can get the point.

The gen~ environment is fun to mess around with in the same way that MSP is: you crack open a gen~ object, add a few operators, and you can hack audio programming while you listen to the results. While it’s always fun to learn and engage with new things, our time is limited, so there’s nothing wrong with wanting to know upfront why it’s useful to learn a new thing. Here are some areas where people with whom I’ve interacted have found learning gen~ to be useful:

While the Max world is full of many objects created by Cycling ‘74 and the Max community, you may find yourself in a situation with no clear solution for the problem you want to solve. Before Gen, your other choice was downloading the Max SDK and creating your external objects. Working with the gen~ object provides you with a third option - a way to make your custom-compiled MSP object without ever having to leave the Max environment.

Here’s an advantage to using the gen~ object that may not be apparent but might be useful to you regardless of your experience level: using gen~ as a way to achieve greater efficiency as you patch. Within the gen~ environment, you can create reusable bits of programming that you use in the same way you use abstractions in Max. One of the advantages of this ability is that you can create gen~ patches that gang together smaller units inside of a single gen~ object. For example, a multi-channel panner/filter/mixer gen~ patch you create can run more efficiently than a similar MSP patch composed of individual objects and abstractions. And the components used don’t have to be complex to see an efficiency improvement. My colleague (and the father of the gen~ object) Graham Wakefield shared an interesting table with some numbers on this subject (see below).

MSP works by processing blocks of samples (called signal vectors). The size of the signal vector was the smallest slice available to you when working with things like delay times, and it meant that there were classes of things - single-sample delay processing or Karplus-Strong plucked string synthesis being two examples - that you really couldn’t do at all. The gen~ environment operates on single samples, so you can start to investigate some new possibilities.

There are procedural programming structures that textual coding languages use that are either difficult or impossible to do in Max - if/then/else conditional statements, or while and for loops. The gen~ environment gives you a way to include them by using the Gen codebox operator (which we'll look at later in the tutorial series). The codebox operator may also be of interest to Max users who prefer writing code or who are interested in porting other people’s examples of textual code (e.g. musicdsp.org) to the GenExpr language that Gen uses internally. 

You can take the contents of your gen~ object and export those contents as C++ code for reuse anywhere where C++ dsp code is useful. In addition to just producing the code, there are audio processing devices out there that let you directly export your gen~ code to run on their devices. The OWL pedal and the Electrosmith Daisypatch Eurorack module are two examples - with more of these on the way.

If you’re interested in any of the five things I’ve listed above, then you’re officially a potential gen~ user. So let’s move on to the next bit: Overcoming gen~ anxiety. 

Over the course of several years, I’ve come to see a particular kind of problem that working in the Gen environment presents: When your beginner self adds a gen~ object to your patch and double-clicks on it to open it, you find yourself in a window that looks like a Max patcher window, but.. it's not. It's got a different-looking toolbar. You’re not sure how to get help, or how to discover what the objects in a gen~ patch do, and even if you figure out things are different, it's hard to know how they're different. The sum total of those differences can seem overwhelming upon first encounter.

In this tutorial series, we are going to look at some things I’ve found help new users make sense of the new gen~ world. They’re small things - often simpler than the smallest of example patches - that will assist you in your transition to having fun with gen~. 

Sigmund Freud describes the purpose of psychotherapy as "the conversion of hysterical misery into common unhappiness." I think that anyone who wants to teach beginners has a kind of common goal - converting hysterical anxiety to common uncertainty. Uncertainty over solving a specific problem is much simpler to deal with than being generally bewildered by the environment you're trying to use to solve the problem. Here begins an ongoing list of entries from my official gen~ Anxiety Top Ten.

Let’s start at the begining. To start patching in gen~, open a new patcher window and add a gen~ object to the patch. When you Command-double-click (or Control-double-click on Windows) to open a gen~ patcher window, you’ll see something that looks like a Max patcher window, but is a little different. Never fear - as a beginner, there are really only a couple of things you need to care about as you begin. 

The first one’s obvious: the locking/unlocking the patcher window is just like Max - a lock in the lower left-hand corner of the patcher window. 

The upper toolbar reflects the fact that the operators available to you don’t include any UI objects (gen~ patchers don’t have them), and the right-hand toolbar will also look familiar, with the exception of the C (Code) icon - a part of the gen~ patcher window that we'll look at in just a minute. The patcher window differences from Max are minimal and easy to get used to - locking/unlocking your patch and using the Code window are all you’ll really need to know, for now.

One way in which the Gen patching environment differs from Max has to do with its discoverability. In an unlocked gen~ patcher window, option-clicking (Macintosh) or alt-clicking (Windows) on any operator will display a reference-like description of the object in a scrolling pop-up window. Since there is a smaller number of gen~ operators, and those operators tend to be more low-level than their Max relatives, the Gen environment uses clear and concise text files rather than more complex help files (and, unlike Max help files, you'll find examples available as files that are distributed with Gen.

Note: To open a full listing of all general objects in the standard Max Documentation Browser, click on the information icon (that little circle with the “i” in it) in the pop-up window. Your selection will appear as the top line of the displayed listing.

Hovering over any inlet or outlet of a gen~ operator will display a Max assistance bubble with information about the inlet or outlet.

When you work with in a gen~ patcher window, you’ll notice that a new icon is displayed on the patcher window’s right border – the Code tab. Clicking on the Code tab’s icon will display the actual code that Gen operators use (called GenExpr) to produce the machine code compiled as you work.

Clicking on any operator in your gen~ patch will highlight the code associated with that operator. As you patch, you can watch the code change in real time as your changes are recompiled in the background. This window is really useful for things like discovering what the default state of an operator is, and when working with the codebox operator.

The Reference icon in a gen~ patcher window behaves similarly to the Reference icon in a Max patcher window: Displaying this window and clicking on an operator displays information about inlets and outlets and attributes associated with an operator.

That’s how you can navigate and figure things out in the gen~ patching environment. 

The Gen environment consists of a smaller set of objects than you’re accustomed to working with in the MSP environment. The operators in the set you’ll work with are inspired by Max/MSP objects, and they’ll often have the same name as their MSP counterparts. In general, the easiest way to think of the gen~ environment is that most low-level MSP object equivalents exist, and the gen~ operators will have more streamlined functionality. The helpfiles in the gen~ environment are textual rather than oriented toward a variety of uses (when it comes to working with buffers, things are a little different, and we’ll talk about that in detail in a later tutorial).

If you don’t find what you’re looking for in that list of Gen operators The gen~ examples folder contains many examples of how the Gen operator set can be used to create patchers that closely resemble the higher-level functionality of other MSP objects. In coming installments, we'll be looking at strategies you can use to extend the usefulness of gen~ operators in simple but useful ways.

In Part 2 of this tutorial series, we'll work on your gen~ anxieties by looking at some of the similarities and differences in the Max and Gen patching environments. Until then, open the gen~ examples folder and have a look around!

gen_starter.png

The first half of the title says it all - this is the first in a series of articles about getting used to the gen~ patching environment if you're a beginner. The goal is about becoming comfortable with the gen~ object and the approaches you might take to do interesting work. 

gen~-for-beginners-part-1-a-place-to-start

Me too! This came at the right time for me as recently I've begun to explore Gen~!

Perfect timing! very much looking forward to working with Gen~ thanks!

Nice intro, Really interested in seeing the next ones! I never used gen~ since I own a max4live license. Just fiddled a bit when renting max for a month and indeed was a bit cryptic 

Brilliant introduction - Thanks very much.
I'm just starting to learn Max on the Kadenze course (very good) and finding the 'black box' granularity a bit difficult to cope with, which I'm currently getting over by connecting number and message boxes to objects so I can 'probe their innards'.
 I'm actually more attracted to Gen than Max based on this introduction as the 'innards' in Gen objects are fully visible in the code window.
Can't wait for the next tut. 

A long time ago to know this gen ~, but do not understand its function, it can let us do?

Just starting out cold, this series is an awesome tutorial!  Thank you for the extra time and effort to put this together in such wonderful "terrified beginner" language Gregory.  Very VERY helpful!

Where is the gen~ examples folder located?

thanks from me too, rereading these for the third time now 🦾
haha, Genius:


how exactly does one open a gen patcher window you seem to have glazed over this pretty important part.

https://docs.cycling74.com/max8/vignettes/gen_overview has a section "Creating a Gen Patch"

also is there no information anywhere on how to actually upload an example? This has to be the least thorough tutorial I've ever seen cycling should really do better than this 



Hello Diego, 
What do you mean exactly? Do you want to upload a patch to this thread?  You can attach files by dragging and dropping, or clicking on the paper clip, or pasting the file from your clipboard.  


My reply with a pointer to the docs seems to have disappeared overnight, strange. 

https://docs.cycling74.com/max8/vignettes/gen_overview - read this.

Anyway Diego, I recommend you spend a bit more time on the basics before jumping into Gen, as you seem to be a complete beginner. And try to remember to be polite, it doesn’t inspire anyone to help you when you are so rude.

Thanks a lot for this series! Very useful. Just bought a Daisy Patch which hopefully will motivate me to take the leap from max and msp and to Gen....

You may find these tutorials (part 1 about setting things up and part 2 about creating some things to download to your Daisy Patch) useful....


Thank you so much for the useful series! Greatly appreciated.

gen~ for Beginners, Part 1: A Place to Start

aceslowman

I am using [maxurl] to make requests to a local node server, which is using a self-signed certificate to serve https (just for local development). As I'd expect, I get:

maxurl: schannel: SEC_E_UNTRUSTED_ROOT (0x80090325) - The certificate chain was issued by an authority that is not trusted.

I am using [maxurl] to make requests to a local node server, which is using a self-signed certificate to serve https (just for local development). As I'd expect, I get:

maxurl: schannel: SEC_E_UNTRUSTED_ROOT (0x80090325) - The certificate chain was issued by an authority that is not trusted.

Is there a way to allow this in Max?

Hello,
I am using [maxurl] to make requests to a local node server, which is using a self-signed certificate to serve https (just for local 

self-signed-certificates-with-maxurl

Found a solution for the time being, I'll try to write out what I did to make this work. On Windows, I had to add the new certificate to the Trusted Root Certification Authority. 

First, make new key (make sure common name is 127.0.0.1 or localhost):
openssl req -x509 -nodes -new -sha512  -days 365 -newkey rsa:4096 -keyout ca.key -out ca.pem
then generate the .crt file:
openssl x509 -outform pem -in ca.pem -out ca.crt
Then, in Windows control panel, go to 'Manage User Certificates', right-click on 'Trusted Root Certification Authorities' -> All Tasks -> Import. Then select your newly created .crt file.

Now Max is no longer throwing an error when making https calls to my local server. Hopefully this is helpful to others that run into this issue, it if there's something that should be done differently I'd love to know.



Self Signed Certificates with [maxurl]

Martin Beck

can someone explain to me what is the expected behaviour of textures and mipmap in processing chains containing jit.gl.slab? The patch illustrates the specific behaviour that is unclear to me:

a) If you apply mipmap filter trilinear to a texture named tex it gets interpolated and shows smooth image.

b) If you pass the same texture to a jit.gl.slab the filter is not applied - the texture looks pixelated.

c) Forcing the slab to rectangle 0 and mipmap trilinear gives different results on Mac or Win 10 (GeForce RTX2080) - Mac works, Win machine produces white texture.

trilinear.png

Scope: I want to apply the mipmap filter at the last stage of my texture processing pipeline and the reported issue on my Windows machine prevents this. Using jit.gl.asyncread and feeding its matrix into a jit.gl.texture with mipmap is my current workaround, but its is not feasible for dynamic texture processing.

NVIDIA GeForce RTX 2080 Driver Version 441.66

Max 8.08 gl2 (there seems to be a similar problem with gl3 but the textures don't turn white but black).

can someone explain to me what is the expected behaviour of textures and mipmap in processing chains containing jit.gl.slab? The patch illustrates the specific behaviour that is unclear to me:
a) If you apply mipmap filter trilinear to a texture named tex it gets interpolated and shows smooth image.
b) If you pass the same texture to a jit.gl.slab the filter is not applied - the texture looks pixelated.
c) Forcing the slab to rectangle 0 and mipmap trilinear gives different results on Mac or Win 10 (GeForce RTX2080) - Mac works, Win machine produces white texture.



Scope: I want to apply the mipmap filter at the last stage of my texture processing pipeline and the reported issue on my Windows machine prevents this. Using jit.gl.asyncread and feeding its matrix into a jit.gl.texture with mipmap is my current workaround, but its is not feasible for dynamic texture processing. 

NVIDIA GeForce RTX 2080 Driver Version 441.66
Max 8.08 gl2 (there seems to be a similar problem with gl3 but the textures don't turn white but black).
Win 10

Hello,
can someone explain to me what is the expected behaviour of textures and mipmap in processing chains containing jit.gl.slab? The patc

mipmap-and-jit-gl-slab

here's how i would handle mipmap filtering at the final stage:

this doesn't work on my Windows machine https://cycling74.com/forums/mipmap-filtering-bilinear-and-trilinear-not-working . The texture turns totally white. I also submitted a problem report some days go.

ok if the patch i posted above isn't working I'm guessing there's a driver issue. i'll try and repro when I get my windows machine back.

Can confirm that the example provided doesn't seem to work in my Windows machine as well. 
It only works with nearest and linear and only in GL2, in GL3 it doesn't work with any setting.
I have set also the Nvidia Control Panel to use bilinear and trilinear optimization for textures, so should be good on that side. 
Graphic card is a Nvidia GeForce GTX 1070, Windows 10, latest Max Release

As of Max 8.2.1 this situation should be greatly improved on both Mac and Windows for both gl2 and gl3 engines.

mipmap and jit.gl.slab

Hello, I found some strange behaviour of mipmap filtering 

On Windows 10 with NVIDIA GeForce RTX 2080 

 filtering result in a totally white gridshape with the attached patch. Is this a bug or hardware limitations? 

 seem to work, but don't yield the required image quality.

The patch works on Macbook 2013, but on Windows no texture is visible with 

Hello, I found some strange behaviour of mipmap filtering bilinear and trilinear in Max 8.0.8 gl2.

On Windows 10 with NVIDIA GeForce RTX 2080 bilinear and trilinear filtering result in a totally white gridshape with the attached patch. Is this a bug or hardware limitations? Linear and nearest seem to work, but don't yield the required image quality. 

The patch works on Macbook 2013, but on Windows no texture is visible with bilinear and trilinear.


Hello, I found some strange behaviour of mipmap filtering bilinear and trilinear in Max 8.0.8 gl2.
On Windows 10 with NVIDIA GeForce RTX 208

mipmap-filtering-bilinear-and-trilinear-not-working

I believe for those modes to work the texture needs to be @rectangle 0 and the dimensions need to be power of 2. I am not at my computer so can’t look at patch but just wanted to mention.

....@rectangle 0  is used in the patch. Would be nice to know if someone else can reproduce the behaviour on Windows. As stated above problem with bilinear and trilinear occurs on Windows 10 but does not occur on Macbook Mojave.

and the texture dimensions are power of 2?

btw, it is unlikely to be an OS difference  but a GPU difference

...more detailed report. So it seems like capturing with jit.gl.node is the problem. It works with a  jit.playlist with matrix output. The problems don't appear on MacBook with NVIDIA GeForce GT 650M 1 GB, but they appear with my Win 10 machine with a NVIDIA GeForce RTX2080.

Can anyone reproduce this behaviour on Windows (patch in previous post)?
So basic problem seems to be that sending a texture to a jit.gl.texture object and apply mipmap bilinear or trilinear in this object results in a totally white texture.
Problem also occurs if using jit.gl.node with these mipmap options.

mipmap filtering bilinear and trilinear not working on Win 10 GeForce RTX 2080

Ted Wiggin

Hoping to trawl for ideas for getting pen pressure from my wacom tablet.

I've been using s2m.wacom for years but I think it may have met its end for me as I haven't been able to get it past apple's gatekeeper software when trying to distribute my standalone.

Any pointers would be appreciated-- I've tried the human interface object with minor success (it works on older tablets but newer ones) Besides that I've been hitting walls

Hi all
Hoping to trawl for ideas for getting pen pressure from my wacom tablet. 

I've been using s2m.wacom for years but I think it may have met its end for me as I haven't been able to get it past apple's gatekeeper software when trying to distribute my standalone.
 
Any pointers would be appreciated-- I've tried  the human interface object with minor success (it works on older tablets but newer ones) Besides that I've been hitting walls

Hi all
Hoping to trawl for ideas for getting pen pressure from my wacom tablet. 
I've been using s2m.wacom for years but I think it may have

alternate-methods-for-wacom-pressure-in-max

Hitting a fresh wave of desperation here. Any thoughts out there?

Good question - I've got a few tablets and ran them through HUI and got zero from the pressure sensitivity. It would be a good feature to be able to access. 

alternate methods for wacom pressure in Max

Paul Zayer

brand new to Max. Using Vizzie to work with movie files. I need to scale down the min-max values in Oscil8r for the frequency function (leftmost dial) from the preset value of 0-40Hz to 0-5Hz. The values I need for manipulating the video content are optimal at very small values. I have "opened" Oscil8r and edited the box labeled "scale 0.1.0.40." which I believed should be responsible for the 0-40Hz values, and saved it with text: scale 0.1.0.10. but this had no change in the values on the dial labeled "frequency" within the "edit patch mode", nor in the Oscil8r module when the editing window was closed. Would greatly appreciate help.

Hi All,
brand new to Max. Using Vizzie to work with movie files. I need to scale down the min-max values in Oscil8r for the frequency function (leftmost dial) from the preset value of 0-40Hz to 0-5Hz. The values I need for manipulating the video content are optimal at very small values. I have "opened" Oscil8r and edited the box labeled "scale 0.1.0.40." which I believed should be responsible for the 0-40Hz values, and saved it with text: scale 0.1.0.10. but this had no change in the values on the dial labeled "frequency" within the "edit patch mode", nor in the Oscil8r module when the editing window was closed. Would greatly appreciate help.
 


Hi All,
brand new to Max. Using Vizzie to work with movie files. I need to scale down the min-max values in Oscil8r for the frequency functi

how-to-change-min-max-frequency-values-in-oscil8r-from-1-40hz-to-1-5hz-using-in-vizzie

change the scale and the dial range (in the inspector)

Hi Double_UG,
thank you for responding! Forgive my utter newness. I thought I did change the scale range (as I described in the original post). As far as the dial, I cannot figure out how to open it up to edit it. I also cannot seem to find a relevant tutorial which puzzles me almost as much.
Any help, and please think very basic, would be great.
I've included the patch. The question is regarding the first top left oscil8r, but is relevant to any oscil8r, or even any device in general. It appears I've saved the desired value for the scale in that oscil8r, but it does not behave differently.
Thanks again!
Paul
PS when I attempt to open the inspector as you suggested, I get a column on the right of my screen which I cannot select any editing parameters from. I clearly am not understanding something very basic...

Beap and VIZZIE ´s are "bpatcher". If you want to make changes in a bpatcher you have to change the Patcher File here "vz.ocsil8r.maxpat", but then all vz.ocsil8r are changed. If you dont want that, you can give the file a new name or check embed Patcher in Parent. 

Tutorial 15: Abstractions
Interface Tutorial 1: bpatchers

How to change min-max frequency values in oscil8r from 1-40Hz to 1-5Hz  (using in Vizzie)

Joe Kaplan

Greetings! I have a header file that defines a class and has a bunch of member functions. Some of those member functions take a callback. I would like to use a Min Function (probably a queue<> function) as one of those callbacks.

But using a member function of one class as a callback in a member function of another class is tricky because C++ secretly applies the prefix "this::" to the return type of member functions. Which means even though my callback returns void, ClassA::void, is not a valid type for a parameter to a function in ClassB.

According to Stack Overflow and some other sources, std::function provides a solution to this. I was able to get it to work if my callback function does something basic like "cout << "hello" << endl;" but if my callback function calls a queue<>, nothing happens.

I suspect this isn't a Min-specific question but has more to do with using C++ properly. But I thought it might be worthwhile to see if anybody here has any experience with this or suggestions for best practices. Thanks in advance!

Greetings!   I have a header file that defines a class and has a bunch of member functions.  Some of those member functions take a callback.  I would like to use a Min Function (probably a queue<> function) as one of those callbacks.

But using a member function of one class as a callback in a member function of another class is tricky because C++ secretly applies the prefix  "this::" to the return type of member functions.   Which means even though my callback returns void, ClassA::void, is not a valid type for a parameter to a function in ClassB.

According to Stack Overflow and some other sources, std::function provides a solution to this.  I was able to get it to work if my callback function does something basic like "cout << "hello" << endl;"  but if my callback function calls a queue<>, nothing happens.

I suspect this isn't a Min-specific question but has more to do with using C++ properly.  But I thought it might be worthwhile to see if anybody here has any experience with this or suggestions for best practices.  Thanks in advance!

Greetings!   I have a header file that defines a class and has a bunch of member functions.  Some of those member functions take a callback.

passing-min-function-as-a-callback-to-a-function-in-another-class

I don't know the C++ answer but I'm interested to hear it from others.

In the C SDK I do this with void pointers. I have a struct created for the job, allocate memory for the struct, put a void pointer to the struct on the callback, and have the receiver take ownership and free the struct's memory when done. If there's no proper C++ answer, you could do that approach!


If you can post the signature of the thing you're calling that takes a callback, I'll try to give specific advice. The likely bottom line is that you'll want it to be able to call queue<>::set() on your Min object in order to enqueue something in the Max main thread, and to do that your callback will need access to a pointer or reference to the instance of your Min object. 

Passing around function-like things in C++ is a good deal more intricate than in C, because there are more types of thing that can behave as if they are functions, and they all have different types (as you've discovered). For instance, the types of a pointer to a 'normal' free function and a pointer to a member function with the same arguments and return type are different. See https://isocpp.org/wiki/faq/pointers-to-members for a discussion of this. 

As well as pointers to functions and pointer to member functions, another common thing to come across in C++ is the idea of a function object, which is some struct that provides an overloaded call operator (operator()), e.g.: 

struct MyFunctionObject{
  void operator()(const std::string& s) { std::cout << s }
}; 

These are very common (see std::plus, std::less etc), partly because C++ doesn't treat functions as first-class objects, and very often we would actually like to pass a whole set of overloads around, which C++ doesn't have a language facility for. Function objects are so common, in fact, that in C++11 they added lambdas as syntactic sugar for defining them quickly. The equivalent to above:  

auto myPrintter = [](const std::string& s) { std::cout << s }; 

Meanwhile, std::function exists as a library-level workaround to the problem that all these different species of Callable thing have different types, even if they have identical effects. It does this by being able to wrap a pointer to a function, or a pointer to a member function, or a function object into an instance of std::function (specialised on the appropriate signature) so that they all then appear to have the same type. This is useful when you want to store a bunch of these things in a homogenous container like std::vector, or where you want to have a function that accepts different kinds of callback, but don't want to write a function template. The trick it uses is called type erasure, and can be thought of as a type safe equivalent to dropping down to void*. However, it doesn't come for free (it may well involve a heap allocation, and will always introduce extra indirection): whether that actually matters depends on the context. 

Min uses std::function in the constructor for queue<>, which expects some callable that takes some atoms and an int, and returns atoms (see c74_min_message.h). It also defines a macro called MIN_FUNCTION that provides the signature for a lambda with the same signature, so that when you declare a queue<> in your Min class, you can just write 

queue<> myQueue { this,
    MIN_FUNCTION {
        do_stuff(); 
        return {};
    }
};

and the compiler will wrap the lambda up into a std::function for you. Calling myQueue.set() then actually does the work of enqueuing a call to your function.

Thank you much for these suggestions.  I am currently focusing on preparing a demo of my current work.  But as soon as I have an opportunity to do some refactoring I will be looking closely at this and trying to implement it.  Just wanted you to know that I saw this post and am grateful for it.

Cycling '74 Forums

We are happy to announce the release of RNBO 1.3.0, available now for download via the Max Package Manager. With this update, we are...

We are excited to announce the availability of our Eventide package for RNBO as a public beta. We’ve worked closely with Eventide to...

Hello I try to find the best way to make any audio file into text I tried to install the aka.listen object but its just not working (I guess

You may find these tutorials (part 1 about setting things up and part 2 about creating some things to download to your Daisy Patch)...

Found a solution for the time being, I'll try to write out what I did to make this work. On Windows, I had to add the new certificate to...

As of Max 8.2.1 this situation should be greatly improved on both Mac and Windows for both gl2 and gl3 engines.

As of Max 8.2.1 this situation should be greatly improved on both Mac and Windows for both gl2 and gl3 engines.

Good question - I've got a few tablets and ran them through HUI and got zero from the pressure sensitivity. It would be a good feature to...

Beap and VIZZIE ´s are "bpatcher". If you want to make changes in a bpatcher you have to change the Patcher File here "vz.ocsil8r.maxpat",...

Hi Owen, Thank you much for these suggestions. I am currently focusing on preparing a demo of my current work. But as soon as I have an...

I encountered and error 126 on Windows issue with sigmund~ 64 bit and thanks to some input from Volker Böhm on Github I was able to resolv

Ye,s I could make it work. Thanks for your help! Also important: Install & Update VIDDLL package, this cost me a few hours.