Trevor being Trevor

This post has a lot of information to give the necessary context, but essentially I can't get the project to build when I add the code to simulate a keystroke and I am not sure why. I was able to figure this out for Windows, but I am running into a problem on Mac that I can't get past. I followed the instructions of this video and github page which seem to be the most up to date.

https://www.youtube.com/watch?v=il5WblTBUgs 
https://github.com/Cycling74/max-sdk/blob/main/README-8.2-update.md 

I started by manipulating the min.hello-world project. I removed the greeting when the object loads, edited the bang function and created a function that responds to integers. Everything compiles and works as expected. However, I want to simulate a keystroke so I brought in the following libraries...

#include <CoreGraphics/CoreGraphics.h>
#include <ApplicationServices/ApplicationServices.h>
#include <Carbon/Carbon.h>

As far as I understand, I only need Application Services, but the other ones were added as I tried to troubleshoot issues. Anyway, to use those libraries I updated my "respond to integer" function to the following code...

message<> number {this, "int", 
        MIN_FUNCTION {
            int key = 56;
            //EDIT: this code is close to correct, but definitely don't trust it.
            //there are better examples on Stack Overflow, if you are really stuck
            //comment and could share something better. Also, it appears
            //olsen put 11strokes code up on Github. It says it's cross platform, so it
            //may be a better and more comprehensive source than what I could offer.
            
            // Create an HID hardware event source
            CGEventSourceRef src = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
            
            // Create a new keyboard key press event
            CGEventRef evt = CGEventCreateKeyboardEvent(src, (CGKeyCode) key, true);
            
            // Post keyboard event and release
            CGEventPost (kCGHIDEventTap, evt);
            CFRelease (evt);
            CFRelease (src);
 
            //this line printed before I added the above
            cout<< "Sometimes I work, sometimes I don't" << endl;
            return {};
        }
    };

Instead of Xcode (I am not very familiar with it) I am using the terminal to build using the command "cmake --build ." inside the build folder which works great. However, the build fails once I add the keystroke specific code. This is the error given with crucial information in bold...

Undefined symbols for architecture x86_64:
"_CFRelease", referenced from:
      hello_world::number::'lambda'(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const&, int)::operator()(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const, int) const in min.hello-world.o
  "_CGEventCreateKeyboardEvent", referenced from:
      hello_world::number::'lambda'(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const&, int)::operator()(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const, int) const in min.hello-world.o
  "_CGEventPost", referenced from:
      hello_world::number::'lambda'(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const&, int)::operator()(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const, int) const in min.hello-world.o
  "_CGEventSourceCreate", referenced from:
      hello_world::number::'lambda'(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const&, int)::operator()(std::__1::vector<c74::min::atom, hello_world::number::allocator<c74::min>> const, int) const in min.hello-world.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Even though it says the issue is for x86_64 I have seen it say arm64 instead as I've tried to get things working. For that reason, I don't think the issue is specific to the architecture, but I could be wrong. Also,  Xcode intellisense autocompletes these symbols as I type them and I am able to right click and "Jump to Definition" so there is a clearly a path to these symbols, but apparently the linker or compiler is unaware of that path. To combat this (and an earlier issue), I tried updating the CMakeLists.txt for min.helloworld to the following...

# Copyright 2018 The Min-DevKit Authors. All rights reserved.
# Use of this source code is governed by the MIT License found in the License.md file.
cmake_minimum_required(VERSION 3.0)
set(C74_MIN_API_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../min-api)
include(${C74_MIN_API_DIR}/script/min-pretarget.cmake)
#############################################################
# MAX EXTERNAL
#############################################################
include_directories( 
	"${C74_INCLUDES}"
	"/System/Library/Frameworks/CoreFoundation.framework/Headers"
    	"/System/Library/Frameworks/ApplicationServices.framework/Headers"
    	"/System/Library/Frameworks/Carbon.framework/Headers" 
    	"/System/Library/Frameworks/CoreGraphics.framework/Headers"
)
set( SOURCE_FILES
	${PROJECT_NAME}.cpp
)

add_library( 
	${PROJECT_NAME} 
	MODULE
	${SOURCE_FILES}
)

target_link_libraries(  
	${PROJECT_NAME}
	"${C74_LIBS}"
	"-framework CoreFoundation" 
    	"-framework ApplicationServices"
    	"-framework Carbon"  
    	"-framework CoreGraphics"
)

include(${C74_MIN_API_DIR}/script/min-posttarget.cmake)
#############################################################
# UNIT TEST
#############################################################
include(${C74_MIN_API_DIR}/test/min-object-unittest.cmake)


Lastly, in trying to figure this out I was made aware of the 11olsen 11strokes project. That could potentially work for me, but I've already built something specific on Windows and replicating it on Mac would be much less future headache if possible. Also, learning is fun most of the time haha. 

Anyway I'm at the point where I don't know how to proceed. It's probably something simple, but this is a bit out of my element so I'm struggling to see it. Any advice or ideas are welcomed and greatly appreciated!

2021 Macbook Pro, M1 Pro, Ventura 13.3.1
cmake version 3.26.0
xcode version 14.3
max version 8.5.3
Let me know if you need anymore info!

This post has a lot of information to give the necessary context, but essentially I can't get the project to build when I add the code to ... 

mac-keystrokes-using-the-mindevkit

Following up on my own post, here's what I did to accomplish the task for those in the future. 

First, I decided to eliminate CMake and the min-devkit as variables completely and just write a basic "Command Line Tool" in Xcode to simulate a keystroke. This was a struggle and I went at the problem from many angles over a couple of days. As far I can tell, this isn't possible via C++ or Apple doesn't let any old app simulate keystrokes anymore . In hindsight, I'm thinking it's the latter. I would run my code, it would trigger Security and Privacy settings and I would allow it, but then it still not give the expected output. As far as I can tell you need to submit some kind of enhancement request now. (I tested this on Apple Silicon and Intel Based Macs by the way)
https://developer.apple.com/forums/thread/28605

Second, from my post above I was now aware of 11strokes by olsen. I downloaded it and tested it in Max, works great! That told me it was definitely possible to simulate keystrokes. In addition, I'm not sure now, but at the time I was suspicious that C++ may be part of the issue. Also I noticed 11olsen used the max-sdk instead of the min-devkit so I decided to switch to that. I am not as familiar with C so it took a little while to understand and get a customized basic object up and running. 

Once that was ready, I brought in the code to simulate a single keystroke. Immediately, I got undefined symbols error I described in my first post. At this point, I knew the problem was with CMake. I needed to manipulate the CMakeLists.txt file located under max-sdk/source/basics/myCustomExternal to make it aware of the Carbon framework I was using. This is what ended up working for me...

include(${CMAKE_CURRENT_SOURCE_DIR}/../../max-sdk-base/script/max-pretarget.cmake)
#############################################################
# MAX EXTERNAL
#############################################################
include_directories( 
	"${MAX_SDK_INCLUDES}"
	"${MAX_SDK_MSP_INCLUDES}"
	"${MAX_SDK_JIT_INCLUDES}"
	/Developer/Headers/FlatCarbon
)
FIND_LIBRARY(CARBON_LIBRARY Carbon /System/Library/Frameworks)
MARK_AS_ADVANCED (CARBON_LIBRARY)
SET(EXTRA_LIBS ${CARBON_LIBRARY})
file(GLOB PROJECT_SRC
     "*.h"
	 "*.c"
     "*.cpp"
)
add_library( 
	${PROJECT_NAME} 
	MODULE
	${PROJECT_SRC}
)
target_link_libraries(myCustomExternal(<-your project name) PRIVATE ${EXTRA_LIBS})
include(${CMAKE_CURRENT_SOURCE_DIR}/../../max-sdk-base/script/max-posttarget.cmake)


The way that CMake is implemented for the sdk would take me, a beginner, at least a few days to wrap my head around. I mostly got there by trail and error and using these sources...
https://gitlab.kitware.com/cmake/community/-/wikis/doc/cmake/platform_dependent_issues/HowToUseExistingOSXFrameworks

https://stackoverflow.com/questions/2908640/how-to-add-a-framework-to-cmake

Mainly the second video in this youtube playlist
https://www.youtube.com/playlist?list=PLalVdRk2RC6o5GHu618ARWh0VO0bFlif4 

Also, the official CMake documentation and ChatGPT gave me a clue at some point. 

Lastly, something that helped me troubleshoot my CMakeLists.txt file was deleting the max-sdk/build folder's contents as I made educated guesses. Then running "cmake -G Xcode .." from the build folder in the terminal and then follow that with "cmake --build ." The first command would usually throw errors if there was something wrong with my CMakeLists.txt.

Overall, I banged my head on this problem for about a week and some of that was definitely my lack of knowledge. However, I think some extra guidance like some common basic CMake manipulations (like adding a framework in my case) would go a long way. Anyway, if this post helps you out with something like this, comment! It would be encouraging to know this helped.

Mac keystrokes using the minDevkit

FelixCode

Hi, I'm a new user and this is my first topic.
I'm studying Max and using the Min-DevKit.
I've been fighting for hours against a problem that I can't understand. When I try to create two Arguments, in the build phase the code fails, but with one it doesn't.
I'm definitely doing something wrong, but unfortunately I can't find where to read up and I'm forced to write a topic hoping to find a solution. I attach two screenshots to better understand.

s1.png

s2.png

Hi, I'm a new user and this is my first topic.
I'm studying Max and using the Min-DevKit.
I've been fighting for hours against a problem ... 

min-devkit-arguments-in-c-errors-building-code

Ok I solved. I had called both the "samples" argument passing the name parameter as "samples", and the identifier name attribute "samples" and this generated conflicts.

Min-DevKit, Arguments in C++ - Errors building code

rvirmoors

Hello, I looked and I haven't seen this already addressed somewhere.

I'm writing an object that's supposed to play a sequence of audio pulses with critical timing accuracy.
So far I've been assuming that every perform() takes the same physical time, and so I use:
playhead += lib::math::samples_to_milliseconds(dsp_vec_size, samplerate())to compute my current time.

The problem is, I also do some other computation in perform() (sending and receiving to/from a LibTorch model), so the resulting clicks are not equidistant.
(i've played with all combinations of Overdrive/Interrupt, same behaviour...)


Is there a way to create a parallel thread with perfect timing accuracy that I can anchor my playhead to?

perhaps using a timer<> like in min.note.make, would that be sample-accurate though?


Hello, I looked and I haven't seen this already addressed somewhere.
I'm writing an object that's supposed to play a sequence of audio ... 

precise-timing-in-min

HIGH STAR RANCH,  is built around community, a colorful local heritage, a love of the outdoors, an appreciation for beautiful living spaces, and a devotion to adventure.
barn wedding venues

oops, scratch this, my code was wrong :) .. perform() does in fact take the same physical time, as it should.

for reference, here's some code to trigger a click every second:
auto vec_size = input.frame_count();
double buf_ms = lib::math::samples_to_milliseconds(vec_size, samplerate());
  playhead += buf_ms;
  for (int c = 0; c < output.channel_count(); c++) {
    auto out = output.samples(c);
    for (int i = 0; i < output.frame_count(); i++) {
      out[i] = 0.;
    }
    if (playhead >= seconds * 1000. - buf_ms) {
      int ratio = (seconds * 1000. - playhead) * vec_size / buf_ms;
      seconds++;
      out[ratio] = -1.;
      cout << "seconds: " << seconds << " ratio " << ratio << endl;
    }
  }
this keeps working even if I add back all the other fancy stuff I had in perform(). yay!


Precise timing in Min?

dyzid

Hey there :)
I need to do some custom initialisation based on arguments for one of my classes. The documentation states I should use a custom constructor for this and by adding const atoms& args = {} as an argument, I should be able to parse them individually.
Unfortunately I found out, that the constructor is called already by pressing space after entering the name of my external into the max object box. In my understanding the constructor should only be called after filling in the arguments and pressing enter, or am I misunderstanding this?
In any case, how am I supposed to get the arguments in the constructor, when it  does not wait for me entering them?

Sorry if this is completely obvious and thanks in advance!

Hey there :)
I need to do some custom initialisation based on arguments for one of my classes. The documentation states I should use a custo

question-arguments-in-constructor

it's possible you are running into a quirk of min based objects where the object's constructor is called once prior to initializing the min wrapper object. So if the object has never been instantiated in the application lifetime this dummy constructor is called. once this happens all other constructor calls are "legit". You could keep track of this using a static variable if needing to handle these dummy calls differently.

Hey Rob, thanks a lot for the answer!
I think I solved it meanwhile, I thought there was no need for the 
argument<number> some_arg {};
calls anymore, when processing them in the constructor.
Now I placed all my argument calls as first thing, and then the constructor, which works perfectly!

All the best :)

Passing arguments in constructor in min-devkit

Joe Kaplan

I copy-pasted some code from the Max API docs into my MIN project and encountered an unexpected error with "object_new".

I used the code example given in the docs under "Creating a Dictionary from JSON" .  I pasted it right into the Hello World external from the default build.  The only modifications I made was to add the c74::max namespace and the instantiate and define the "jsontext" variable.

Is there something else I need to do to prepare object_new?  Thank you for any assistance.  This would be a valuable addition to my project.

t_dictionary    *d = NULL;
t_max_err       err;
t_atom          result[1];
t_object        *jsonreader = (t_object*)object_new(_sym_nobox, _sym_jsonreader);
// assume we have an argument called 'jsontext' which is a const char* with the JSON
// from which we wish to create a t_dictionary instance
err = (t_max_err)object_method(jsonreader, _sym_parse, jsontext, result);
if (!err) {
t_object *ro = (t_object*)atom_getobj(result);
if (ro) {
if (object_classname_compare(ro, _sym_dictionary))
           d = (t_dictionary*)ro;
else
object_free(ro);
   }
}
object_free(jsonreader);
// we now have a t_dictionary in d that can be used as we see fit

image.png

I copy-pasted some code from the Max API docs into my MIN project and encountered an unexpected error with "object_new".
I used the code exa

min-problem-converting-json-to-dict-linker-issue-with-object_new

Can anybody assist with this?  My project is at a standstill until I get this sorted.  Any input would be much appreciated.

The first issue is that the object_new method is actually a macro from `ext_obex.h` in the max-sdk-base. This will result in invalid code when you try to prepend it with `c74::max::` when the preprocessor expands the macro. You might need to `#undef object_new`?

There might also be namespace clashes with the common symbols you're passing into object_new. They're common symbols (which is basically an optimization so that you don't have to call `gensym()` every time you want to use some common symbol).  

At the moment I don't have an immediate answer on how to properly call object_new for what you're aiming for, but this should be possible with some tinkering. I'd have to take a closer look to provide any code snippets. 

I just wanted to chime in here.

Mixing and matching Max API code and Min code requires a bit of careful understanding of how each of them work. It's typically preferable to rewrite the code using Min based idioms or being careful with direct use of the Max API inside Min code. Now that we've made this easier to do with the Max 8.2 SDK, we realize that it would probably be good for us to establish some tips on common issues that might occur when mixing and matching the Min and Max APIs (a few of which you've discovered here).

We'll try to do this in the near future, however please note that as a small company, our support for third party development is limited. We don't have a dedicated staff to help with these classes of problems, and assume that people entering into the world of coding take on a lot of responsibility to solve their own problems. We do try to help when we can, however, and in the meantime, thank you for your patience.

Thanks to you both!  I really appreciate it.  This has been a learning project for me, and it has taken me much deeper than I expected.  But I've definitely learned a lot and am very excited about the potential results.  I'm getting very close to having all my bases covered as far as SDK is concerned!

I was able to get the Max API code to compile as soon as I quarantined it in it's own block to keep it separate from the Min namespace.

So I think I'm now on the path to a viable solution.  The last wrinkle here seems to converting a Min dict to a Max t_dictionary* and back.  

Writing a JSON parser for Min, and reverse engineering the dictionary API both sound like daunting tasks for a novice programmer.  Any tips on how to make this conversion would be a big boost in getting this work across the finish line.

Thanks again for your assistance and kind consideration.   
-Joe

Well, I discovered  that I can cast a min::dict to a max::t_object* and then cast the max::t_object* to a max::t_dictionary*.   A max::t_dictionary* casts back to a min::dict no problem.

sadly, I was mistaken when I said the code had compiled when I quarantined the namespace. (newb error here, but I see what I did wrong).  Although the IDE doesn't report problems with that approach, I still get linker errors.   Not as close to the finish line as I thought.

I'll look forward to additional docs and caveats when working with Max API code in Min.    Meanwhile, I'll study up on the fundamentals of both APIs, and see if I can figure it out.  Or get started on a JSON <-> min::dict converter, which might be easier.

Meanwhile, any additional insight into how to execute the example code in MIN would be a big help.

Thanks a ton for everything already!  The Max team has been  integral in helping me get started here.

there seem to be a few issues wrapped up in this post, and as Joshua mentioned mixing min-api with max-sdk code is tricky business.

max-sdk uses common-symbols (e.g. _sym_dictionary, etc)  all over the place, but this is not something min exposes or wraps AFAICT. the easiest way to proceed may be to replace any uses of these symbols with c74::max::gensym(). However if you'd like to use these, you must do two things:

first include common_syms.c into your project this can be achieved by modifying your projects cmakelists to include the file like so:

set( SOURCE_FILES
  ${PROJECT_NAME}.cpp
  ${MAX_SDK_INCLUDES}/common/commonsyms.c
)

second you must call c74::max::common_symbols_init(); in your object constructor (or at some other initialization point, prior to when the symbols are referenced).

converting a c74::max::t_dictionary to a min dict is as simple as dict mindict {maxdict};
But you must be very careful about dict ownership when passing around dictionaries, as mentioned in the min dict header documentation.

using object_new also takes some care, and will give different outcomes depending on what namespaces are currently active.

here's code that I was able to compile and run in a min hello-world project (that includes commonsyms as described above) that creates a max dictionary, converts it to a min-dict and prints the contents:

message<> test { this, "test", "Post the greeting.",
 MIN_FUNCTION {
  using namespace c74::max;
  t_dictionary* d = NULL;
  t_max_err       err;
  t_atom          result[1];
  t_object* jsonreader = (t_object*)object_new(_sym_nobox, _sym_jsonreader);
  const char* jsontext = "{\"name\":\"John\", \"age\":30, \"car\":null}";
  err = (t_max_err)object_method(jsonreader, _sym_parse, jsontext, result);
  if (!err) {
   t_object* ro = (t_object*)atom_getobj(result);
   if (ro) {
    if (object_classname_compare(ro, _sym_dictionary)) {
     d = (t_dictionary*)ro;
     dict mindict {d};
     c74::min::symbol key {"name"};
     c74::min::atom value = mindict[key].begin();
     cout << "key: " << key << ". Value: "  << value << endl;
    }
    else
     object_free(ro);
   }
  }
  object_free(jsonreader);
  return {};
 }
};

Thank you for all the input here!  I wish I could say this last post got me running.  

I'll  do more research into common symbols in Max API to understand how to replace them with gensym().   For now, I thought I'd try bringing common symbols into Min for this one task.  

Rob, the instructions above worked!  I was able to build with commonsyms.c and print the contents of mindict.

I encountered trouble when I tried to send the dictionary out the outlet though.    Its giving me an access violation deep in c74_min_outlet.h.

I simply added the line:  output.send("dictionary", mindict.name()); 
immediately after you print to the console 

My .cpp file is attached.  I created a new message test2, just to confirm I am able to output dictionaries correctly.  I am able to use that same syntax to output a different dictionary.   I'm not sure what the matter is here.

/// @file
///	@ingroup 	minexamples
///	@copyright	Copyright 2018 The Min-DevKit Authors. All rights reserved.
///	@license	Use of this source code is governed by the MIT License found in the License.md file.

#include "c74_min.h"

using namespace c74::min;


class hello_world : public object<hello_world> {
public:
    MIN_DESCRIPTION	{"Post to the Max Console."};
    MIN_TAGS		{"utilities"};
    MIN_AUTHOR		{"Cycling '74"};
    MIN_RELATED		{"print, jit.print, dict.print"};

    inlet<>  input	{ this, "(bang) post greeting to the max console" };
	outlet<> output {this, "(anything) output the message which is posted to the max console"};

    hello_world() {
		c74::max::common_symbols_init();
    }


    message<>     test {this, "test", "Post the greeting.", MIN_FUNCTION {using namespace c74::max;
    t_dictionary* d = NULL;
	t_max_err     err;
	t_atom        result[1];
	t_object*     jsonreader = (t_object*)object_new(_sym_nobox, _sym_jsonreader);
	const char*   jsontext   = "{\"name\":\"John\", \"age\":30, \"car\":null}";
	err                      = (t_max_err)object_method(jsonreader, _sym_parse, jsontext, result);
	if (!err) {
		t_object* ro = (t_object*)atom_getobj(result);
		if (ro) {
			if (object_classname_compare(ro, _sym_dictionary)) {
				d = (t_dictionary*)ro;
				dict             mindict {d};
				c74::min::symbol key {"name"};
				c74::min::atom   value = mindict[key].begin();
				cout << "key: " << key << ". Value: " << value << endl;
                output.send("dictionary", mindict.name());   //Problem occurs here.
			}
			else
				object_free(ro);
		}
	}
	object_free(jsonreader);
	return {};
}
};

    message<>     test2 {this, "test2", "Post the greeting.", MIN_FUNCTION {using namespace c74::max;
        dict d {c74::min::symbol(true)};
	    d["name"] = "jimbob";
	    output.send("dictionary", d.name());

        return {};
		}
		};    
    


};


MIN_EXTERNAL(hello_world);


It looks like the problem here is that mindict.name() is returning a null value.

I tried adding a function to c74_min_dictionary to rename the dict  with a value I specify using:
m_instance        = max::dictobj_register(d, &s);

But I can't find a way to do that that doesn't clear the contents of mindict in the process.


the following works for me and is able to send the dictionary out for viewing in dict.view. This is just for demonstration and a real solution would need to manage the objects, or free them after output:
https://gist.github.com/robtherich/19b12d27f5a31cd5e1e6af6de34fa65e 

I was just about to post my own solution, which was to initialize another min dictionary with {c74::min::symbol(true)}, and then use copy unique() to move the contents of mindict into the new dictionary.  

Registering the t_dictionary properly in the first place is even better.

Deep appreciation to C74 for this.  Thank you.

message<> dictionary{this, "dictionary", "Dictionary is received",
MIN_FUNCTION{try {dict noteDictionary = {args[0]}; ... etc

How do you read `noteDictionary` into the json reader? In the examples above, the dictionary is constructed as const char*   jsontext   = "{\"name\":\"John\", \"age\":30, \"car\":null}";

If using the `message<> dictionary{this, "dictionary",` function I wanted to try and read the object/atoms?

I'm not certain I'm following your question, but this is how I was able to take a dictionary into an inlet and convert it to JSON.

Toward the end of the  Min Documentation , there is a section that covers the fundamentals of dealing with dictionaries.

Inside your MIN FUNCTION, you can use dict d(args[0]);
to  take the incoming dictionary and write it to a variable named "d."

Then feed "d" into the proper JSON reading function per the Max API docs.  Below is how I did it.

const char* convertDICTtoJSON(dict d){
        using namespace c74::max;
        t_object* object = d;
        t_dictionary* maxdict = (t_dictionary*)object;
        t_object* jsonwriter = (t_object*)object_new(_sym_nobox, _sym_jsonwriter);
        t_handle    json;
        const char* str;
        object_method(jsonwriter, _sym_writedictionary, maxdict);
        object_method(jsonwriter, _sym_getoutput, &json);
        str = *json;
        // now str contains our JSON serialization of the t_dictionary d
        object_free(jsonwriter);
        return str;
    }

In order to use these functions you have to make the additions to cmakelists that Rob recommends above.  You have to do this for cmakelists for the individual object, not for the package.   Don't forgot to rebuild your package with the appropriate cmake commands afterward.

MIN:  Problem converting JSON to DICT  (linker issue with object_new??)

R Kumar

Hi,
I am just getting my feet wet in developing externals. It is my understanding that min SDK seems to be limited in exposing the implementation of the underlying MAX SDK. I am liking the ease with which we can create an external object in C++ and bind the messages for appropriate callback. At some places, I do struggle to implement functionality in MAX SDK using the min framework - (I have not been able to figure out how to respond to the inletinfo message to mark an inlet as cold and I have been using direct calls to max::jgraphics object to get finer control on working with text layouts and justifications.)

My question to the forum is - do we have a recommended way of using the underlying MAX SDK? I am fairly conversant with programming, but new to C / C++. How do we get C++ objects to pass sucessfully into the C functions. I figured t_object* can be got from maxobj(). I am now trying to figure out how to pass a function pointer and register for callback using the class_addmethod function in a C++ class.

tx

Hi,
I am just getting my feet wet in developing externals. It is my understanding that min SDK seems to be limited in exposing the implement

mixing-min-and-max-sdk

with the 8.2 update to the max-sdk (and corresponding updates to min), externals that mix max-sdk C function calls with min C++ should easier to develop, since both now utilize the same base headers and libs. There is not much in the way of recommended practice other than, be careful with namespaces. You can see an example of this in my reply here.

Hello Rob,
Thanks. I had seen this thread a few weeks back and it really helped me getting to use Dictionaries and JGraphics from the MAX sdk. This method however does not seem to work for everything.

Currently I am studying the ITM module of MAX and trying to create a simple metro that will send a bang on every beat. Min Timers seem to not be tempo aware and don't seem to have any way of performing quantization.

Any pointers / examples? MAX crashes when I use the  class_time_addattr to define a time attribute. MIN has an object called time_value. I am not sure how to use it.


OK. So, I am now using a combination of the min timer and max ITM information. I am defining a min timer object (example found in documentation (http://cycling74.github.io/min-devkit/guide/initialization).

timer<> midiClock{ this,
        MIN_FUNCTION{
            //This is just the definition of the timer.
            //and the link to the timer call back function
            midiTick();
            return{};
        }
    };

And in the midiTick function, I figure out what the global tempo is and schedule the next call to tick appropriately.

//Get the Tempo and schedule the next tick
max::t_itm* globalITM = (max::t_itm*)max::itm_getglobal();
double tempo = max::object_attr_getfloat(globalITM, max::gensym("tempo"));
double tickDelay = 60000 / (480 * tempo);
midiClock.delay(tickDelay);

I have used 480 above so the delay is equal to one midi-tick based on the tempo. But we can change that as needed. I am not sure if this is an elegant solution as I am fetching the tempo on every tick. I however did not find a way in which I could be notified using min-devkit if the user changed the tempo.


Mixing Min and Max SDK

I spent quite some amount of time trying to figure out how to use the live.colors object to link the Live color schemes to my external C++ UI object. For anyone struggling to make the link between the internal colour names given by live.colors and the names that are displayed on the dynamic colour list of a colour attribute,  this post might help.

Here is how to define a colour attribute that is linked with the Abelton colour scheme using min-devkit:
attribute<color> attr_name{     //This is used to reference the attribute within our code
        this,                   //Pointer to your our object
        "attr_name",            //Internal identifier for MAX. What we put here appears in the 
                                //Attribute list that is displayed when typing the name of our 
                                //component in max patcher
        color {{1.,0.,0.,1.}},  //Default value - does not matter as the attribute is initialized to 
                                //the live colour defined below
        title {"active_automation"},//Name displayed in the object information panel for this 
                                    //attribute
        description{"Live Color - Active Automation"},  //Helper description
        live_color{"active_automation"}    //The name here is the output of the live.color object 
                                           //when responding to "everything" message
    };

Forgive the formatting above as I am still trying to figure out out to post effectively on this forum. The mapping of the internal live.color names to the names displayed on the colour picker when dynamic colours are selected is as below.
Note: Some of the displayed names are duplicates. I am not sure how live.color object differentiates them

Internal Name				Dislayed Name
active_automation			Automation
assignment_text_bg			Mapping Highlight
contrast_frame				Control Border
control_bg					Control Off
control_fg					        Text / Icon On
control_fg_off				        Text / Icon Off
control_fg_off_zombie		Text / Icon Off (Inactive)
control_fg_on				        Text / Icon On
control_fg_on_zombie		Text / Icon On (Inactive)
control_fg_zombie			Control Range Off (Inactive)
control_fill_handle			Control Handle
control_selection			        Control On
control_text_bg	                        Text Background
control_text_selection		Text / Icon On
control_text_zombie			Text / Icon On (Inactive)
control_zombie				Control On (Inactive)
dial_fg	Control 			        Range On
dial_fg_zombie				Control Range Off
dial_needle	                                Control Needle On
dial_needle_zombie			Control Needle Off
dial_triangle				        Control Triangle
display_handle_one			LCD Handle
display_handle_two			LCD Handle Variant
display_line_one			        LCD Shape
display_line_two			        LCD Shape Variant
display_scale_text			LCD Background Text
focus_frame	Control 		Selection Frame
freeze_color				        Freeze
gain_reduction_line_color	Gain Reduction Line
inactive_automation			Automation Override
input_curve_color			Input Curve
input_curve_outline_color	Input Curve Outline
key_assignment				Mapping Key
lcd_bg	LCD 				        Background
lcd_control_fg				LCD Text / Icon
lcd_control_fg_alt			        LCD Text / Icon Variant
lcd_control_fg_zombie		LCD Text / Icon (Inactive)
lcd_frame					        LCD Line
led_bg						        LED Background
macro_assigned				Mapping Macro
macro_assignment			Mapping Macro
macro_title					Control Header
meter_bg					        Control Background
midi_assignment				Mapping Midi
numbox_triangle				Numbox Triangle
output_curve_color			Output Curve
output_curve_outline_color	Output Curve Outline
selection					        Control Highlight
spectrum_alternative_color	Spectrum Variant
spectrum_default_color		Spectrum
spectrum_grid_lines			Spectrum Grid
surface_bg					Device Background
surface_frame				Line
threshold_line_color		        Threshold Line
value_arc					        Control On Variant
value_arc_zombie		        Control Range On (Inactive)
value_bar					        Sliding Range Value

I spent quite some amount of time trying to figure out how to use the live.colors object to link the Live color schemes to my external C++ U

min-devkit-m4l-color-attributes

Min DevKit M4L color attributes

I'm working on a  package that requires some custom properties  (i have some additional includes and linker setup to manage, etc.).  I have made a VS Property Sheet sheet with all the necessary adjustments.  Once I've complied the package with CMAKE I can use the Property Manager view in visual studio to apply that property sheet to each project in the solution.  

This works well enough.  But when I want to add a new object to the object I have to recompile the package using CMAKE.  After I do this all of the projects in my package have reverted back to the default properties.  So every time I add an object I have to re-adjust the properties for all of the existing objects.  

In addition to being some painful manual labor, there is a high chance of error.  It feels like there should be a better way.

I'm wondering if there's a way to include my property sheets in the build script for the projects.  Can anyone suggest some solutions or best practices?

Greetings,
I'm working on a  package that requires some custom properties  (i have some additional includes and linker setup to manage, etc.

best-practices-when-dealing-with-min-and-vs-property-sheets

https://stackoverflow.com/questions/2973263/add-visual-c-property-sheets-using-cmake 

Best practices when dealing with Min and  VS Property Sheets?

George Collins

Heya,

I'm waning to create a function that can disable and enable the dsp within my external, so that it can save resources when it isn't needed without the need for deleting the object in MAX.

I thought I'd start off by trying calling dsp_free() for disabling and dsp_setup() for enabling. Whilst it does stop and start the audio processing, on disabling (dsp_free) it sends out a nasty noise (like a saw tooth wave) permanently until I call dsp_setup() again.

Is there a proper way to do this within-side an external?

Cheers!

Heya,

I'm waning to create a function that can disable and enable the dsp within my external, so that it can save resources when it isn't n

dsp_free-is-it-possible-to-disable-and-enable-dsp-within-an-external

First of all, dsp_setup() and dsp_free() allocate and deallocate internal resources to allow Max to successfully include your object perform routine in the DSP chain. They are intended to be called in your "myobject_new" and "myobject_free" methods respectively. Nowhere else in your code you should be calling dsp_setup() and dsp_free().

The way you bypass audio processing in your external is very simple, maybe too simple...
In your perform method you write:

if (x->bypass) {
    while (sampleframes--) {
        *out++ = *in++;
    }
    /*
    or you could write also:
    sysmem_copyptr(in, out, sizeof(double) * sampleframes);
    */
}
else {
    // do your dsp here...
}

Obviously that's pseudo-code that I just wrote off the top of my head, but it should give you the idea.
Hope it helps.

Awesome, that helps a lot. Thanks Luigi! 

dsp_free() - is it possible to disable and enable DSP within an external?

esnho

I'm trying to set an array of long to a jitter matrix but looks like the values have a weird offset.

I've wrote a gist with a snippet of code that can reproduce the isse.
It basically fills the matrix with a counter value.
https://gist.github.com/esnho/c6a86d82e8f18a812c9edef4448a529c

And attached below you can see the difference between reading the matrix from a Max object and printing the values directly from C, what's going on?

Screenshot 2020-09-20 at 12.49.39.png

Screenshot 2020-09-20 at 12.49.33.png

Hello,
I'm trying to set an array of long to a jitter matrix but looks like the values have a weird offset.
I've wrote a gist with a snippet

how-to-set-an-array-of-long-to-jitter-matrix-properly

i believe you need to set 2 flags in the matrix info struct in order to successfully execute your code

info.flags = JIT_MATRIX_DATA_REFERENCE | JIT_MATRIX_DATA_PACK_TIGHT;

since your creating as data-reference, you also need to explicitly set the matrix size:

info.size = info.dim[0] * info.planecount * SIZE_INT32;

the other tricky bit is long as your data array type is not correct on all platforms. long data type in jitter is actually implemented as int (actually t_int32). and not on all platforms is sizeof(long) == sizeof(int).

so you should create an int array instead of long, and pass that to the matrix data call.

give that a try and let us know if that works.

That's works well, I've commented the gist to reflect the changes.

https://gist.github.com/esnho/c6a86d82e8f18a812c9edef4448a529c#gistcomment-3464921 

Cycling '74 Forums

Following up on my own post, here's what I did to accomplish the task for those in the future.

Ok I solved.

oops, scratch this, my code was wrong :) ..

Hey Rob, thanks a lot for the answer! I think I solved it meanwhile, I thought there was no need for the argument<number> some_arg ...

Hi Venetian, I'm not certain I'm following your question, but this is how I was able to take a dictionary into an inlet and convert it to ...

OK. So, I am now using a combination of the min timer and max ITM information.

I spent quite some amount of time trying to figure out how to use the live.colors object to link the Live color schemes to my external C++ ...

https://stackoverflow.com/questions/2973263/add-visual-c-property-sheets-using-cmake

Awesome, that helps a lot. Thanks Luigi!

That's works well, I've commented the gist to reflect the changes. It also works well using float as ...