Cherry Audio Forums

Aarnville wrote: ↑Sat Sep 03, 2022 5:12 pmIt's this sort of stuff that CA could do with including in their dev kit documentation - a "best practice" list.

ColinP wrote: ↑Sat Sep 03, 2022 7:46 pm I usually handle trigger input detection inside ProcessSample() using something like this...

Code: Select all

   if( whateverIn.IsConnected() )
   {
      // detect rising edge...
      if( whateverIn.GetValue() >= TRIGGER_THRESHOLD )
      {
         // whatever input is high
         if( whateverInDetected == false )
         {
            // rising edge detected
            whateverInDetected = true;
            bingo();
         }
      }
      else
      {
         // trigger input is low
         whateverInDetected = false;   
      }
   }
   else
   {
      // disconnected...
      whateverInDetected = false;
   }
   

Initialte a trigger like so...

Code: Select all

   thingyOutCountdown = TRIGGER_LENGTH;

Handle trigger output in ProcessSample() like so...

Code: Select all

   if( thingyOutCountdown > 0 )
   {
      thingyOut.SetValue( TRIGGER_VOLTAGE );
      thingyOutCountdown--;
   }
   else
      thingyOut.SetValue( 0 );
      

Constants defined by...

Code: Select all

private static final double TRIGGER_THRESHOLD = 2.5;
private static final double TRIGGER_VOLTAGE = 5.0;
private static final int TRIGGER_LENGTH = 48;   // duration in samples of trigger outputs (1 mS)

Single sample duration triggers work fine most of the time but are fragile in complex patches because of propagation delays. Extending the trigger duration makes it less likely that logic signals that you would expect to match get lost because of one or two samples worth of delay somewhere along the road.

if (trigReset.Triggered(inputReset.GetValue()))  
{
  // triggered

ColinP wrote: ↑Sat Sep 03, 2022 8:57 pm I note your code example uses a method called Triggered(). I find it really annoying that CA break the Java convention and make their method identifiers look like class names and I have to handle a disjointed thought and reach for the shift key every time I use a CA method name. What's your reasoning?

Aarnville wrote: ↑Sun Sep 04, 2022 8:23 am No reasoning, it's just that underneath it all I'm a C programmer and I am still absorbing the Java style so my earlier stuff in particular is sometimes inconsistent.

Aarnville wrote: ↑Sun Sep 04, 2022 8:23 am You'll notice that I like my opening curly braces on their own line so the closing brace matches up with it.

if( a )
{
   b();
   c();
}

if (a) {
   b();
   c();
}

Aarnville wrote: ↑Sun Sep 04, 2022 8:23 am (On a related subject: message to Cherry Audio devs. In the next version of the editor please can we have a "highlight matching braces" option. Ta.)

Aarnville wrote: ↑Sun Sep 04, 2022 8:23 am That was the module where I learned about the 64k size limit on any Java class. My chord "wizard" class contains hundreds of chord progressions in a large constant array. During development it only had a handful of chord progressions for testing purposes so it was quite annoying to find the 64K limit right near the end of the project when I added in the rest of the data. A 64k limit in 2022!!!

4.10 Limitations of the Java Virtual Machine
The following limitations of the Java virtual machine are implicit in the classfile format:

* The per-class or per-interface constant pool is limited to 65535 entries by the 16-bit constant_pool_count field of the ClassFile structure (�4.1). This acts as an internal limit on the total complexity of a single class or interface.

* The amount of code per non-native, non-abstract method is limited to 65536 bytes by the sizes of the indices in the exception_table of the Code attribute (�4.7.3), in the LineNumberTable attribute (�4.7.8), and in the LocalVariableTable attribute (�4.7.9).

4.11. Limitations of the Java Virtual Machine
The following limitations of the Java Virtual Machine are implicit in the class file format:

The per-class or per-interface constant pool is limited to 65535 entries by the 16-bit constant_pool_count field of the ClassFile structure (§4.1). This acts as an internal limit on the total complexity of a single class or interface.

The number of fields that may be declared by a class or interface is limited to 65535 by the size of the fields_count item of the ClassFile structure (§4.1).

Note that the value of the fields_count item of the ClassFile structure does not include fields that are inherited from superclasses or superinterfaces.

The number of methods that may be declared by a class or interface is limited to 65535 by the size of the methods_count item of the ClassFile structure (§4.1).

Note that the value of the methods_count item of the ClassFile structure does not include methods that are inherited from superclasses or superinterfaces.

The number of direct superinterfaces of a class or interface is limited to 65535 by the size of the interfaces_count item of the ClassFile structure (§4.1).

The greatest number of local variables in the local variables array of a frame created upon invocation of a method (§2.6) is limited to 65535 by the size of the max_locals item of the Code attribute (§4.7.3) giving the code of the method, and by the 16-bit local variable indexing of the Java Virtual Machine instruction set.

Note that values of type long and double are each considered to reserve two local variables and contribute two units toward the max_locals value, so use of local variables of those types further reduces this limit.

The size of an operand stack in a frame (§2.6) is limited to 65535 values by the max_stack field of the Code attribute (§4.7.3).

Note that values of type long and double are each considered to contribute two units toward the max_stack value, so use of values of these types on the operand stack further reduces this limit.

The number of method parameters is limited to 255 by the definition of a method descriptor (§4.3.3), where the limit includes one unit for this in the case of instance or interface method invocations.

Note that a method descriptor is defined in terms of a notion of method parameter length in which a parameter of type long or double contributes two units to the length, so parameters of these types further reduce the limit.

The length of field and method names, field and method descriptors, and other constant string values (including those referenced by ConstantValue (§4.7.2) attributes) is limited to 65535 characters by the 16-bit unsigned length item of the CONSTANT_Utf8_info structure (§4.4.7).

Note that the limit is on the number of bytes in the encoding and not on the number of encoded characters. UTF-8 encodes some characters using two or three bytes. Thus, strings incorporating multibyte characters are further constrained.

The number of dimensions in an array is limited to 255 by the size of the dimensions opcode of the multianewarray instruction and by the constraints imposed on the multianewarray, anewarray, and newarray instructions (§4.9.1, §4.9.2).

constant_pool_count
The value of the constant_pool_count item is equal to the number of entries in the constant_pool table plus one. A constant_pool index is considered valid if it is greater than zero and less than constant_pool_count, with the exception for constants of type long and double noted in §4.4.5.

constant_pool[]
The constant_pool is a table of structures (§4.4) representing various string constants, class and interface names, field names, and other constants that are referred to within the ClassFile structure and its substructures. The format of each constant_pool table entry is indicated by its first "tag" byte.