updated CMake and -1 bug investigation

Author: tremblap

CMakeLists.txt

@@ -1,19 +1,34 @@
+set(FILENAME "IBufWr.cpp") #specify the .cpp file here
 cmake_minimum_required (VERSION 2.8)
-set(PROJECT "IBufWr")
+get_filename_component(PROJECT ${FILENAME} NAME_WE) #automatically sets project name from the filename
+# set(PROJECT "my_name") #alternatively set project name manually
+message(STATUS "Project name is ${PROJECT}")
 project (${PROJECT})
 
 include_directories(${SC_PATH}/include/plugin_interface)
 include_directories(${SC_PATH}/include/common)
 include_directories(${SC_PATH}/common)
 
-
 set(CMAKE_SHARED_MODULE_PREFIX "")
 if(APPLE OR WIN32)
 set(CMAKE_SHARED_MODULE_SUFFIX ".scx")
 endif()
 
+option(SUPERNOVA "Build plugins for supernova" OFF)
+if (SUPERNOVA)
+    include_directories(${SC_PATH}/external_libraries/nova-tt)
+    # actually just boost.atomic
+    include_directories(${SC_PATH}/external_libraries/boost)
+    include_directories(${SC_PATH}/external_libraries/boost_lockfree)
+    include_directories(${SC_PATH}/external_libraries/boost-lockfree)
+endif()
+
 option(CPP11 "Build with c++11." ON)
 
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+	set(CMAKE_COMPILER_IS_CLANG 1)
+endif()
+
 if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANG)
     add_definitions(-fvisibility=hidden)
 
@@ -66,4 +81,9 @@ if(MINGW)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mstackrealign")
 endif()
 
-add_library(${PROJECT} MODULE IBufWr.cpp)
+add_library(${PROJECT} MODULE ${FILENAME})
+if(SUPERNOVA)
+    add_library(${PROJECT}_supernova MODULE ${FILENAME})
+    set_property(TARGET ${PROJECT}_supernova
+                 PROPERTY COMPILE_DEFINITIONS SUPERNOVA)
+endif()

release-packaging/IBufWr/HelpSource/Classes/IBufWr.schelp

@@ -69,6 +69,8 @@ For a more detailed explanation and thorough justification of the usefulness of
 STRONG:: Basic Usage: Comparing BufWr and IBufWr::
 
 code::
+s.boot;
+
 (
 // define 2 small buffers
 b = Buffer.alloc(s, s.sampleRate);
@@ -115,12 +117,16 @@ c.getn(0,31, {|msg| msg.postln});
 // but it gets nasty if you change the speed of playback, especially if you read faster than the writing was done, because of these empty indices skipped in the writing process.
 {BufRd.ar(1,[b.bufnum, c.bufnum],Phasor.ar(0, 11 , 0, b.numFrames),0,1)}.play
 
+// clean up
+b.free;c.free;
 ::
 
 
 STRONG:: A More Musical Example: Emulating a Resampling Digital Delay::
 
 code::
+s.boot;
+
 //create a one second buffer
 b = Buffer.alloc(s, s.sampleRate);
 
@@ -174,14 +180,15 @@ y.set(\gain, 0)
 x.free
 y.set(\feedback, 0.8)
 
-// free the delay
-y.free
-b.free
+// free the delay and both buffers
+y.free; b.free; d.free;
 ::
 
 STRONG:: Yet Another Musical Example: Processing Within the Feedback Loop::
 
 code::
+s.boot;
+
 //create a one second buffer
 b = Buffer.alloc(s, s.sampleRate);
 
@@ -195,7 +202,7 @@ d = Buffer.read(s, p);
 x = d.play(true, 0.1)
 
 // add a basic delay after using the built-in DelayN, 6dB lower -- feedbback does not work, needs a block delay (InFeedback)
-y = {arg gain = 0.5, feed = 0.5; [0, DelayN.ar((In.ar(0) * gain) + (In.ar(1) * feed),0.2,0.2)]}.play(addAction:'addToTail')
+y = {arg gain = 0.5, feed = 0.5; [0, DelayN.ar((In.ar(0) * gain) + (In.ar(1) * feed),1,1)]}.play(addAction:'addToTail')
 
 // so free that
 y.free
@@ -216,10 +223,10 @@ y = {
 
 // ...but gets nasty when the duration is changed, especially when shorter than the original, as it skips samples and most probably reads in these samples skipped at writing time...
 y.set(\dur, 0.91111)
-x.free
+x.free;
 
-y.free
-b.zero;
+// clean up
+y.free; b.zero;
 
 // this works better using IBufWr
 // start the sound source
@@ -241,9 +248,7 @@ y = {
 y.set(\dur, 0.91111)
 
 // and more fun - set a 400 ms filtered looper
-y.set(\gain, 0);
-y.set(\feedback, 1);
-y.set(\dur, 0.4);
+y.set(\gain, 0, \feedback, 1, \dur, 0.4);
 
 // send some stuff in, then cut the source
 y.set(\gain, 1);
@@ -253,29 +258,25 @@ y.set(\gain, 0);
 y.set(\dur, 0.8)
 
 // with smoothing
-(
-y.set(\gain, 1);
-y.set(\lag, 0.4);
-y.set(\dur, 0.2);
-y.set(\feedback, 0.7);
-)
+y.set(\gain, 1, \lag, 0.4, \dur, 0.2, \feedback, 0.7);
 
 // cool stop!
 (
-y.set(\feedback, 0.9);
-y.set(\lag, 2);
-y.set(\dur, 2);
-x.free
+y.set(\feedback, 0.9, \lag, 2, \dur, 2);
+x.free;
 )
 
-y.free
+//clean up
+y.free; b.free; d.free;
 ::
 
 STRONG:: A kr example: using a synchronously mutating stereo buffer as sequencer::
 
 code::
+s.boot;
+
 // allocate a small buffer for the sequence
-e= Buffer.alloc(s,1000,2)
+e= Buffer.alloc(s,1000,2);
 
 // start the fun!
 (
@@ -291,8 +292,11 @@ e= Buffer.alloc(s,1000,2)
 )
 
 // plot regularly to enjoy the sequence
-e.plot
+e.plot;
 
 // when it's too much, zero the lfo buffer
-e.zero
+e.zero;
+
+// clean up
+e.free;
 ::

release-packaging/IBufWr/HelpSource/Guides/BufferWritingGuide.schelp

@@ -13,6 +13,8 @@ Both link::Classes/BufWr:: and link::Classes/IBufWr:: behave the same way, which
 
 strong::Example 1: Basic Stereo Buffer Writing::
 code::
+s.boot;
+
 // allocate a stereo buffer
 c = Buffer.alloc(s, s.sampleRate,2);
 
@@ -32,10 +34,15 @@ c = Buffer.alloc(s, s.sampleRate,2);
 	);
 }.plot(0.1)
 )
+
+//clean up
+c.free;
 ::
 
 strong::Example 2: Common Error, too large an input array::
 code::
+s.boot;
+
 // allocate a stereo buffer
 c = Buffer.alloc(s, s.sampleRate,2);
 
@@ -50,10 +57,15 @@ c = Buffer.alloc(s, s.sampleRate,2);
 }.plot(0.1)
 )
 // check the Post Window, you get told off!
+
+//clean up
+c.free;
 ::
 
 strong::Example 3: Common Error, multichannel expansion of the index (phase) input::
 code::
+s.boot;
+
 // this code will try to multichannel expand the index(phase) input.
 // allocate a stereo buffer
 c = Buffer.alloc(s, s.sampleRate,2);
@@ -74,6 +86,9 @@ c = Buffer.alloc(s, s.sampleRate,2);
 	);
 }.plot(0.1)
 ) // if that was working we would expect 2 parallel lines, the 2nd perforated since we skip at the same speed than the values...
+
+//clean up
+c.free;
 ::
 
 subsection:: The Main Differences between BufWr and IBufWr
@@ -85,6 +100,8 @@ strong:: Variable CPU taxing::
 link::Classes/IBufWr:: needs to check if there is an index or more that has been skipped, which implies some branching in the code, which takes CPU time. Even at one-sample-per-sample writing speed, it is less efficient than link::Classes/BufWr:: because of that check.
 
 code::
+s.boot;
+
 // declare a buffer
 b = Buffer.alloc(s, s.sampleRate);
 
@@ -154,14 +171,22 @@ g = Group.new;
 )
 // now the interpolation hits even more.
 g.free
+
+//free the buffer
+b.free;
 ::
 
 strong:: 1 sample late::
 
 The way link::Classes/IBufWr:: interpolates is by making the difference between indices. What this implies is that at the end of a vector, the known value of the last sample will not be known until the first value of the next vector. In a code where the writing happens right before the playing, it creates a whole in the output. The discriminating ear will have heard that in the previous examples above. This is in fact written as soon as possible, as one can see in the example below:
 
 code::
+s.boot;
+
+//allocate a small buffer
 b = Buffer.alloc(s, 200);
+
+//writing at the same time as reading
 (
 b.zero;
 {
@@ -189,3 +214,27 @@ b.plot
 strong::negative index::
 
 A feature of link::Classes/IBufWr:: is that the writing can be paused at any time, by providing negative indices. Once the writing starts again, the first index is not interpolated from the previous positive entry.
+
+code::
+s.boot;
+
+//allocate a second-long buffer
+b = Buffer.alloc(s, s.sampleRate/10);
+
+//writing with a switch on the index every 250ms
+(
+b.zero;
+{
+	IBufWr.ar(
+		Phasor.ar(0, 1 , 0, b.numFrames),// writing values, incremented one sample per sample
+		b.bufnum,
+		LFPulse.ar(40,mul:Phasor.ar(0, 1 , 1, b.numFrames+1),add:-1), // writes one sample per sample when the pulse is up, otherwise is stable at -1
+		1
+	);
+}.plot(0.1)
+)
+
+b.plot
+
+b.free
+::