bolprocessor-devel — Bol Processor developer discussion list

[bp-dev] A MacOS standalone application "BolProcessor.app"

[Bernard B. <ber...@gm...>]

The Bol Processor on MacOS is now a standalone application 
"BolProcessor.app" (based of PHP Desktop) that no longer requires an 
additional installation.

Great news, because running the free version of MAMP had limitations, 
and using XAMPP is a bit awkward to set up automatically on startup.

The installer is used for both the initial installation and updates.

Check this page to download the (notarized) installer:
https://bolprocessor.org/quick-install-macos/

[bp-dev] Version 3.2.1 is precompiled for MacOS

[Bernard B. <ber...@gm...>]

Dear colleagues,

Version 3.2.1 of the Bol Processor has some important improvements:

1) For MacOS users: the installer copies the compiled "bp" console, so 
there is no need to compile it. (The same applies to "bp.exe" on the 
Windows installation).

2) The interface now checks the PHP version, its extensions and the 
architecture of the computer's system. It gives warnings on the front 
page if a 64-bit architecture is not used, or if GD graphics and 
multibyte Unicode are not handled.

The standalone version of Bol Processor for MacOS is not yet ready... 
The current version of PHP Desktop fixes problems with creating tags 
versus windows, but its "php-cgi" does not have the "gd" and "mbstring" 
extensions. The "gd" extension is needed for graphics. I've spent 
several days trying to recompile a "php-cgi" with the necessary 
extensions, to no avail! PHP specialists are needed for help.
Visit: https://github.com/cztomczak/phpdesktop/issues/363

Install the latest version of BP3 and its PHP interface with our 
installers or scripts for MacOS, Windows and Linux:
https://bolprocessor.org/install/

Visit our website: https://bolprocessor.org

Bernard Bel

[bp-dev] Version 3.2.0 at last!

[Bernard B. <ber...@gm...>]

Dear colleagues,

I have completed and uploaded version 3.2.0 of the Bol Processor, in 
which important changes have been made, although these may not be 
audible in the examples. However, they may be noticeable on some MIDI 
instruments or when capturing MIDI events.

The main change is the management of NoteOn/NoteOff messages, described 
on the page
https://bolprocessor.org/control-noteon-noteoff/

It took me a long time to revise pages such as “FillPhaseDiagram.” and 
“MakeSound.c”, which account for most of the changes.

In the interface, a number of PHP lines were fixed to comply with PHP 
version 8 requirements.

I also worked on the MacOS and Windows installers. Both installers need 
to check which Apache server is being used: MAMP and XAMPP. In MacOS, 
the owner/group permissions in the “bolprocessor” folder are fixed 
accordingly.

The Windows installer “BolProcessorInstaller.exe” is now certified. Read 
more at
https://bolprocessor.org/quick-install-windows/
This was a painstaking process, given the vague documentation provided 
by the certification agent… All in all, it took me no less than a month!

Install the latest version of BP3 and its PHP interface with our 
installers and scripts for MacOS, Windows and Linux:
https://bolprocessor.org/install/

Visit our website: https://bolprocessor.org

Bernard Bel

[bp-dev] New Year's updates

[Bernard B. <ber...@gm...>]

Dear all,

First of all, I would like to wish you all a happy new year: success, 
health and peace, despite the appalling international situation...

I've spent many days (and nights) fixing problems that have arisen 
following reports from a new user. I hadn't checked the installation and 
operation in MacOS carefully enough, feeling confident because the 
console and its interface were developed on my Mac with the latest 
version of the system. Part of the problem is that I am using MAMP PRO, 
which behaves differently to MAMP (free) and XAMPP. So when problems 
were reported, I checked installations on different Macs and Apache servers.

MAMP and XAMPP run as different identities in MacOS. While MAMP uses 
your personal identity (by default), XAMPP uses "daemon". The user/group 
parameters of the "bolprocessor" folder (and all its contents) must 
therefore be different for these Apache servers, i.e:

daemon:admin for XAMPP
<user_id>:admin for MAMP

So I modified the installer to detect the presence of XAMPP and change 
the parameters accordingly.

I then installed MAMP (free) on one Mac and XAMPP on another Mac (which 
also runs MAMP PRO). There were three surprises:

1) MAMP (free) on MacOS keeps the time limit at 30 seconds, even when 
the PHP script tries to increase it. This is a surprise as there is no 
such limit on Windows. The result is that small projects with short 
execution times work fine, but larger ones (such as "-da.La_Campanella") 
end up with a "System error #500". There seems to be no way to fix this 
except by upgrading to the commercial MAMP PRO.
2) XAMPP works fine, but getting it to start Apache at boot time is not 
satisfactory. There are scripts available (at 
https://github.com/erwinagpasa/Launching-XAMPP-at-OSX-startup) that will 
automatically start Apache, but if real-time MIDI is used, 
MIDIClientCreate() returns an error. The only way is to run 
"manager-osx.app" and start (or restart) Apache manually. I've spent a 
whole day trying to restart Apache automatically in the console, but it 
never works because the restart command has to be called from "root". I 
may find a solution in the next few days, but until then the easiest way 
is to find "manager-osx.app" (in XAMPP/xamppfiles) and add it to the 
login items of the general settings of your MacOS system.
3) Since I'm running PHP version 7.4 on my MAMP PRO server, I hadn't 
noticed that PHP higher than 8.1.0 changed the parameters of some 
functions used for graphics. So the images were blank!  I fixed this in 
the interface.

All these changes are announced on the pages:
https://bolprocessor.org/quick-install-macos/
https://github.com/bolprocessor/bolprocessor/blob/graphics-for-BP3/BP3-changes.txt

Regarding Windows, I found out that the "BolProcessorInstaller.exe" 
works fine on my machine only because it was created on the same 
machine... This means that other machines will send a warning that it is 
from an "unknown author" and even trash it as "containing a virus"! This 
means that it needs to be certified in the same way as the MacOS 
installer.  I started this process, which is supposed to be free, but 
for which I paid more than 120 euros for a "cryptographic card" sent 
from Germany (https://shop.certum.eu). :-(

Wait and see...

Bernard Bel

[bp-dev] (No) compute while playing

[Bernard B. <ber...@gm...>]

Dear colleagues,

Version 3.0.19 of the Bol Processor supports the "Compute while playing" 
option (checked by default) and the "Max advance time" parameter, which 
sets the maximum time for the computation ahead of the performance. This 
is useful to ensure proper synchronisation when multiple instances of 
BP3 take turns: uncheck "Compute while playing" and set "Max advance 
time" to less than 2 times the expected duration of each production.

"Pause" and "Continue" can also be controlled by receiving the standard 
Pause and Continue MIDI events.

More details:
https://bolprocessor.org/real-time-midi/

Install BP3 and its PHP interface using our installers in MacOS and 
Windows, scripts in Linux:
https://bolprocessor.org/check-bp3/

All the best,

Bernard

[bp-dev] Json settings format + Pause/Continue

[Bernard B. <ber...@gm...>]

Dear colleagues,

Version 3.0.17 of the Bol Processor adds "Pause" and "Continue" buttons 
when playing a piece of music in real-time MIDI.

You might ask: why hasn't this been done before? Actually, it wasn't 
difficult, given the recent development of real-time MIDI processes. But 
I got the motivation when it became necessary to solve musical problems!

Another significant update is the storage of settings in a structured 
JSON format, which will make it easier to create new parameters in 
future developments. The old format (a plain text file listing numbers) 
is automatically converted to the new format. A simple edit of the 
"settings_names.tab" and "settings_template" files will allow the 
creation or deletion of parameters and still work with the old material.

Install BP3 and its PHP interface using our installers:
[https://bolprocessor.org/check-bp3/](https://bolprocessor.org/check-bp3/)

All the best,

Bernard

[bp-dev] Progress on distribution

[Bernard B. <ber...@gm...>]

Dear colleagues,

I have spent this month designing better distributions of the Bol 
Processor in the three environments (MacOS, Windows, Linux).

First of all, to make the interface more attractive, thanks to several 
colour 'skins' that will be updated from time to time. I have a 
preference for the blue skin in dark mode, which is the one selected by 
default...

But the most important work is not yet visible. Czarek Tomczak has 
released the long-awaited distribution of his "PHP Desktop" package for 
MacOS. Windows and Linux versions were already up and running 
(https://github.com/cztomczak/phpdesktop).

In a nutshell, PHP Desktop emulates a Chrome browser and a built-in 
Apache server. The package has a "www" folder. The magic is that if you 
fill this folder with the contents of "bolprocessor" (which includes the 
console, all the PHP files and the data), you get a version of Bol 
Processor that requires no installation of MAMP or XAMPP, no GCC 
compiler, etc. And you can still develop the interface by editing the 
PHP files. No 'compilation' required!

I have verified that these standalone versions of Bol Processor work 
perfectly with MacOS and Windows. I haven't yet checked Linux, but it 
should work as well. However, there are a few issues that need to be 
fixed (in PHP Desktop) before distributing these packages. For example, 
the "_blank" links open new windows instead of new tabs, window sizes 
can't be controlled by PHP, etc. All issues are listed and discussed here:
https://github.com/cztomczak/phpdesktop/issues

I hope that PHP Desktop will reach its full functionality soon, so that 
we can distribute the Bol Processor to musicians who are reluctant to 
install MAMP or XAMPP, even if they are for free...

Meanwhile, I have made life easier for Windows users: the Bol Processor 
installer now includes a pre-compiled console 'bp.exe'. This avoids the 
hassle of installing MinGW to run the GCC compiler. The simple 
installation is explained here:
https://bolprocessor.org/quick-install-windows/

I still have a lot of work to do on analysing captured MIDI data and 
reusing it in grammar/data projects:
https://bolprocessor.org/capture-midi-input/

All the best,
Bernard

[bp-dev] Dance in the dark!

[Bernard B. <ber...@gm...>]

Dear colleagues,

Given my painful experience with cathode ray tube screens on early 
computers, I feel uncomfortable with any piece of software that displays 
a dark work desktop. These have become popular with younger generations 
who didn't have this experience… That's why I felt challenged to create 
a dark interface of the Bol processor. To prove that it can't be that good?

The new interface in this 'Halloween' version has an icon in the top 
right corner that switches the light on and off with a single click, so 
you can compare. Personally, after working hard on the CSS design, I 
have changed my mind!

Bol Processor version 3.0.15 has new features in its core engine that 
are more audible than visible. These include a _part() command that 
allows each part of a score to be assigned to a specific MIDI device, 
regardless of the MIDI channels that need to be reserved for 
microtonality 
(https://bolprocessor.org/real-time-midi/#the-_part-command). Parts 
defined in MusicXML scores are automatically mapped to parts, channels, 
or/and Csound instruments.

Install (or update) BP3 in MacOS/Windows/Linux:
https://bolprocessor.org/check-bp3/

... and dance in the dark! 😀

All the best,
Bernard

[bp-dev] Capturing MIDI events

[Bernard B. <ber...@gm...>]

Dear colleagues,

As announced in the previous message, I have implemented a "capture" 
command that records incoming MIDI events to text files. Details can be 
found on this page:

https://bolprocessor.org/capture-midi-input/

Making sense of musical events produced by a human performer or another 
machine is an enormously challenging and promising task. The first step 
will be to translate captured sequences into polymetric expressions 
using acceptable approximations. Then we will try to construct grammars 
that produce musical material similar to the captured one.

Next weekend I will be attending a concert and workshop dedicated to the 
use of the Djazz model of "musical learning" 
(https://digitaljazz.fr/research/). I am confident that it will generate 
many fruitful ideas!

All the best,
Bernard

[bp-dev] MacOS installer is certified 😀

[Bernard B. <ber...@gm...>]

A quick note: after several days of unsuccessful attempts, I had a 
successful run of the "xcrun notarytool submit 
BolProcessorInstaller.pkg" command, which gave the correct certification 
to the MacOS installer of the Bol Processor (see 
https://bolprocessor.org/quick-install-macos/).

In effect, users are no longer warned that this application is 
potentially malicious, and they don't have to bypass the protection in 
their system settings… This makes a difference!

Finding the right parameters and options was a headache, and even 
ChatGPT often often took me off track.

All the best,
Bernard

[bp-dev] Microtonality in realtime MIDI

[Bernard B. <ber...@gm...>]

Dear colleagues,

I have completed the implementation of tools for using microtonal scales 
in realtime MIDI and MIDI files on BP3, now completely independent of 
Csound.

First of all, scale models can be imported and exported from/to SCALA 
and KBM files. In this way, tuning schemes designed on the Bol Processor 
can be used by other music software tools.

However, this is 'static' use, as a single tuning must be applied to an 
entire musical work, which is acceptable in classical/baroque music 
genres. In addition, BP3 offers "dynamic" microtonal adjustments to 
notes sent via MIDI. Several scales can be used on the same piece, and 
even assigned to different voices (within polymetric structures).

A comprehensive but detailed presentation of the new features can be 
found on this page:
https://bolprocessor.org/check-midi-microtonality/

You will admit that, since the project is not focused on a limited 
number of musical genres, scales can be designed with numbers of degrees 
and notes other than 12. "Exotic" cases are illustrated by examples on 
the Microtonality page.

A promising feature is the microtonal adjustment of input events:
https://bolprocessor.org/check-midi-microtonality/#tuning-input-notes

Since several instances of BP3 can be running at the same time, you can 
set up a number of "tuners" interacting with people and MIDI devices, 
each using its own tonal system.

I am now trying to work out how to "capture" NoteOn/NoteOff events to 
translate the input into polymetric structures. This could be a first 
step towards working with AI "language models" capable of exploring the 
syntax of the Bol Processor. I am trying to take inspiration from 
successful AI models such as Djazz (https://digitaljazz.fr/research/).

All the best,
Bernard

[bp-dev] Microtonality no longer exclusive to Csound

[Bernard B. <ber...@gm...>]

Dear colleagues,

Thanks to discussions with sound designers and musicians using the most 
recent software, I realised the importance of separating the design of 
tonal scales from "Csound resources". Until now, the two were tied 
together because I hadn't imagined producing microtonal music without 
Csound...

The new version of Bol Processor (3.0.5) uploaded today brings two 
important features:

1) Tonal structures are designed independently and stored as "tonal 
files" in a folder called "tonal_resources" and shared by all projects. 
A tonal file (prefix "-to") contains any number of scales (tuning 
schemes). These can be easily copied between different files and note 
names can be changed as required: English, Italian/French, Indian and 
key number conventions.

If you load an old "-cs" file defining Csound instruments, the interface 
will automatically split it into a "-cs" file without the scales, and 
create a "-to" file with the scales. It will then fix the links in 
projects so that the two remain associated, if desired.

2) Each scale can be exported in the SCALA format 
(https://www.huygens-fokker.org/scala/scl_format.html), widely used for 
tuning digital instruments.

One limitation of the SCALA approach seems to be that the "tuning" 
cannot be changed at different points in the performance, for example 
when dealing with ascending and descending movements. I am trying to 
implement the same flexibility we have with Csound and the _scale() 
performance control.

Perhaps the MIDI Polyphonic Expression (MPE) protocol 
(https://midi.org/mpe-midi-polyphonic-expression) would be a solution: 
assign a different MIDI channel to each degree of the scale and create 
PitchBend messages to adjust them to the desired tuning. Please let me 
know if this is a viable approach, or suggest alternatives! I will at 
least check it out on my PianoTeq synth…

The installers for the MacOS, Windows and Linux versions work 
beautifully and make it very easy to install or update the Bol 
Processor. I am currently testing it in the three environments.
Follow instructions: https://bolprocessor.org/check-bp3/

All the best,
Bernard Bel

[bp-dev] Installers for Windows, MacOS and Linux

[Bernard B. <ber...@gm...>]

Dear colleagues,

I have created installers for Windows and MacOS, and a set of scripts 
for installing BP3 on Linux.
Read details:

https://bolprocessor.org/quick-install-macos/
https://bolprocessor.org/quick-install-windows/
https://bolprocessor.org/check-bp3/

These make it possible to install the console files, the PHP interface 
and the set of sample files (ctests) in a single click. The same 
installers can be used to upgrade the installation to a new version, 
automatically fetching the latest distribution.

In Linux, the same is achieved by running a few shell scripts (download 
https://bolprocessor.org/misc/linux-scripts.zip) that make each step 
more explicit. The Linux environment is more demanding in terms of 
owners and permissions, all of which are taken care of by the scripts.

This is certainly a step in the right direction, as it will encourage 
more musicians to try out the Bol Processor without being hampered by 
technical issues.

The next step on the agenda will be to separate the design of 
(microtonal) tunings from Csound instruments, and to export tuning 
schemes in the Scala (SCL) file format.  In this way, we'll be able to 
combine the theoretical frameworks of micro-intonation with the 
technical quality of high-end sound design environments.

All the best,
Bernard

[bp-dev] A triathlon of software engineering, and a call to musicians

[Bernard B. <ber...@gm...>]

Hi all,

Swimming on MacOS, cycling on Windows and running on Linux! The complete 
setup of the Bol Processor BP3 (https://bp3.tech) has been trialed in 
these 3 environments. That deserved a medal, given the endurance 
required to program advanced MIDI features. The outcome: several 
instances of BP3 can operate simultaneously, like “virtual musicians” 
synchronising their actions in an “orchestra”, communicating with MIDI 
devices as well as… human musicians! (https://bp3.tech/real-time-midi/)

Writing code was a tedious task due to the constraints of each 
environment. Fortunately, AI tools made it possible in a matter of weeks.

Up to now, with the emphasis on writing code, the items shared for demos 
have been of relatively little musical interest. Simplistic examples 
were preferred because they are easy to understand. We are entering a 
new phase: musicians are invited to use BP3 to create high quality 
musical works, as these will convince more and more of their colleagues 
that an approach based on musicological research is fruitful.

All the best,
Bernard

[bp-dev] BP3 fully functional on Windows!

[Bernard B. <ber...@gm...>]

Hello everyone,

I managed to acquire a second-hand HP machine that is entirely dedicated 
to compiling and testing the Bol processor on Windows 10 and, very soon, 
Linux. This was essential as the update to compile and run on Windows 
took more than ten days (and nights)!

The result is here:
https://github.com/bolprocessor/bolprocessor/archive/graphics-for-BP3.zip
https://github.com/bolprocessor/php-frontend/archive/master.zip
https://github.com/bolprocessor/bp3-ctests/archive/main.zip

The updated installation instructions:
https://bolprocessor.org/check-bp3/

Surprisingly, installation on Windows is easier than on MacOS, if we 
exclude additional tools (such as MinGW) for compilation. To facilitate 
the first approach, I also distribute the pre-built console ("bp" or 
"bp.exe"), which should work out of the box if users feel safe to ignore 
security warnings.

Thanks to the LLDB debugger and compiling with the AddressSanitizer 
option (on the Mac), as well as advice from ChatGPT, I was able to trace 
outdated or problematic programming habits. The Mac still accepted them 
because they were inherited from MacOS 9, but Windows didn't. Most of 
them involved low-level procedures, such as handling text files in a 
multi-platform format.  I realised that many of these issues had been 
raised and documented by Anthony Kozar a long time ago. :-)

By comparison, updating the MIDI driver (for real-time input and output) 
was not difficult, as the AI tool provided very pedagogical advice. My 
guess is that adapting the code to Linux will be very easy. The Linux 
code is already in the distribution, but it hasn't been tested yet. I 
need to create a partition on the boot disc and install Linux plus all 
the development tools.

While I was designing, I remembered that many of the algorithmic 
structures of the program, which worked in earlier versions, could still 
be revived. For example, analysing objects with grammars, as we used to 
do a long time ago - on an Apple II!

I am so busy programming, and so excited about the benefits of AI tools, 
that I have stopped looking for programmers. What we need most are 
musicians and high-calibre composers to create musical examples of great 
musicality. This will complement the "technical" examples that 
demonstrate the features of the Bol processor model, but are not 
musically significant.

Enjoy the new version and send your comments and suggestions!

Bernard

[bp-dev] Multiplatform development + prefixes

[Bernard B. <ber...@gm...>]

Hello everyone,

I spent a few days using AI tools to update the MIDI driver code that 
will be compiled on Windows and Linux. I mean, procedures that will be 
identical to those that currently give full satisfaction on MacOS. This 
is not an easy task, as the handling of MIDI input/output events is 
quite different on the three platforms, and yet they all need to match 
the BP3's handling of time…

Now I have to check the compilation and finish the code!  I am trying to 
acquire a cheap machine that will boot both Windows 10 and Ubuntu, which 
will be dedicated to running BP3 in the three environments. You can send 
me compilation errors if you dare, but I think things will go faster if 
I can make the corrections immediately.

Another important change is the introduction of more meaningful 
prefixes/suffixes for files describing alphabets and sound objects:
- Prefix "-ho" and suffix "bpho" replaced by "-al" and "bpal" (alphabet 
files)
- Prefix "-mi" and suffix "bpmi" are replaced by "-so" and "bpso" (sound 
object files).

These changes are automatically managed by the interface and the console.

The old prefixes/suffixes were used to denote homomorphisms and MIDI 
codes. Alphabet files may still contain homomorphisms, but this no 
longer needs to be highlighted. Sound objects can now contain Csound 
scores in addition to, or instead of, MIDI codes.

The display of the file index in each workspace has been improved: each 
file is placed in a specific box according to its type. This makes life 
a lot easier. ;-)

The latest version can be downloaded as usual:
https://github.com/bolprocessor/bolprocessor/archive/graphics-for-BP3.zip
https://github.com/bolprocessor/php-frontend/archive/master.zip

I am now on the hunt for good musical examples!

Bernard

[bp-dev] Fully interactive BP3

[Bernard B. <ber...@gm...>]

Hello everyone,

I have completed the implementation of features that make BP3 a fully 
interactive multitasking composition/improvisation program in the MIDI 
environment.

The meaning of "multitask" is that any number of instances of BP3 can 
run simultaneously on the same computer, using the same web browser, or 
on multiple computers connected by MIDI cables or other networking 
facilities such as BlueTooth.

What is more, these instances can communicate with each other and with 
other MIDI devices - including human musicians! - to create a "virtual 
band" of synchronised units.

Each unit has an unlimited number of MIDI input and output ports to 
which event types and/or channels can be filtered. The limit, of course, 
is the MIDI setup (managed by Audio MIDI Setup and IAC on the Mac).

You can read and listen to examples on the page:
https://bolprocessor.org/real-time-midi/

So far these developments have been compiled and tested on MacOS, but 
the code is (almost) ready for Windows 64 bits and Linux. I am trying to 
find a second-hand PC to finish the compilation.

More features will be implemented to take full advantage of the 
interactions. Scripts developed for BP2 will be restored and adapted to 
the new platform.

We now need musicians with compositional training to take these tools 
and create examples with valuable musical content!

I am very happy to see this progress.

Bernard

[bp-dev] MIDI input and filtering

[Bernard B. <ber...@gm...>]

Dear colleagues,

After days of intensive work, I have completed the implementation of 
input MIDI event handling.

This paved the way for the restoration of scripts that can be viewed as 
"input time objects". Many script instructions had been created for BP2 
which I plan to revive. For now, the only instruction that works in BP3 
is a pause waiting for a specific note, for example
_script(IN wait for C3 channel 1)
which is self-explanatory. If it is placed at the beginning of a piece, 
its performance will start exactly when the machine has received note C3 
channel 1 from a piano keyboard, another MIDI device or another instance 
of BP3.

MIDI events received by BP3 can be ignored, processed, or processed and 
forwarded to the output MIDI device. Filtering incoming events is a new 
feature of BP3 - again, a remake of an existing feature of BP2. Filters 
are set via the PHP/Javascript interface and associated with the 
'project' (a grammar or set of data).

All features work perfectly on the Mac. Conditional programming has been 
used for compilation on Windows and Linux. However, these need to be 
checked and fixed on real machines. I have already received reports from 
a very kind Windows user that have allowed me to fix many 
inconsistencies. These inconsistencies occur when variables or data 
types conflict due to unwanted identical names. I am now making 
arrangements to get a Windows machine and speed up this process.

Managing real-time MIDI events in BP3 is very different from BP2, mainly 
because BP2 produced time-stamped MIDI events that were managed by the 
OMS environment. Currently we need to create a stack of events in BP3 
and send them at the exact time they are needed...

The use of PortMidi (https://github.com/PortMidi/) could replace the 
current procedures in MIDIdriver.c and secure the implementation of 
real-time MIDI in the three environments. Although it makes it easier to 
program low-level MIDI features, it seems that installing PortMidi 
itself requires technical skills on the part of the user. However, we 
are keeping this option open in case installation becomes easier. To 
give you an idea, installing PortMidi on my (recent) Mac required the 
following sequence of instructions (with the help of ChatGPT!)

git clone https://github.com/PortMidi/portmidi.git
cd portmidi
mkdir build
cd build
brew install cmake
cmake -DCMAKE_OSX_ARCHITECTURES=arm64 ...
make
sudo make install

Several times it was necessary to set permissions in the system settings.

I am now working on building a substantial set of script instructions 
that will be used to communicate with external MIDI devices.

All the best,
Bernard

[bp-dev] Running multiple instances of BP3

[Bernard B. <ber...@gm...>]

Hi all,

The new version of BP3 I have just uploaded supports running multiple 
instances of BP3 on the same browser. The STOP button now stops the 
performance it is attached to, while the PANIC button stops all 
performances.

Also, the STOP and PANIC buttons are always effective because a 
session_abort() was needed in produce.php before the command was sent to 
the console. This took me a long time to figure out!

You may wonder about the interest of playing an improvisation of 
Mozart's dice game over Liszt's La Campanella... ;-) But the idea is 
that we'll soon be able to handle input MIDI events, so these instances 
will be able to communicate and control each other (along with external 
MIDI devices) in terms of synchronisation and parameter changes.

This means that we launch multiple instances, each of which is a single 
"musician" waiting for a specific MIDI code to start its performance. 
Each performance will also send synchronisation signals to other 
"musicians". External human-operated MIDI devices (e.g. a piano 
keyboard) will trigger or control various things in this "orchestra".

The control will include changing parameters in grammars, which may have 
an influence on changing the weights of some rules and thus changing the 
grammar itself ("live coding").

This is the task environment I had developed on earlier versions of BP2, 
but at that time (in India) I did not have the equipment to connect 
several instances of BP2 - each on a different computer - so it remained 
a wish for the future! The future is TODAY :-)

Needless to say, we need musicians who can develop demos that make sense 
musically, in addition to technical demos with a minimum of material!

I am now working on MIDI input event handling to reproduce (and extend) 
the features of BP2.

MIDI source and output ports can now be set up on the interface. The 
console checks that these ports are available and suggests changes to 
numbers and names if the match is not perfect. Ports are saved with each 
project (Grammar or Data).

Progress has been made on checking compilation under Windows, although 
it is not yet complete. This isn't an easy task due to the specific 
implementations of real-time MIDI.

All the best,
Bernard

[bp-dev] images, Csound, Panic

[Bernard B. <ber...@gm...>]

Hello,

I have just uploaded revised versions of the console and its interface.

No changes to core algorithms. I only fixed problems with the display of 
images. For example, there was a tiny bug in "Timeset.c" that 
incorrectly calculated the left image border when an out-time object was 
at time = 0.

Overall, small bugs can take a long time to resolve! :-\

It was also necessary to fix the coordinates of the graphics in order to 
deal with very large images. The "canvas" graphic scheme has limitations 
that make it impossible to handle coordinates greater than "a certain 
amount", which I estimate at 16383... As this is a limitation of web 
browsers, we can hope that their designers will extend the range.

A nice new feature is the addition of start dates near the links to 
(sound-object) images in "Improvize" mode. This will later be applied to 
"pianoroll" images.

The new interface also accepts alternative names for the Csound console, 
which may be required to run Csound on Windows.

Finally, I created a "PANIC" button that creates a "_stop" file in the 
"temp_bolprocessor/messages" folder.  It is intended to stop the console 
in improvise mode or when it is playing a long piece in realtime MIDI. 
As I explained earlier, it does not always work because the browser 
session is "hogged" by the console. One trick was to restart Apache. Now 
the same can be achieved by clicking "PANIC" on a different browser 
(running a different session).

I am still looking for a method to send a system command to the console, 
perhaps from Javascript... But my "colleague" ChatGPT pretends it is 
impossible for security reasons!

All suggestions and comments welcome!

Bernard

[bp-dev] Version 3.0 with real-time MIDI output!

[Bernard B. <ber...@gm...>]

Dear colleagues,

I am very proud to announce the completion of the real-MIDI output on BP3!

As usual, the updated console can be downloaded from
https://github.com/bolprocessor/bolprocessor/archive/graphics-for-BP3.zip

along with its HTML/PHP/Javascript interface from
https://github.com/bolprocessor/php-frontend/archive/master.zip

and its sample set:
https://github.com/bolprocessor/bp3-ctests/archive/main.zip

A (fresh new) history of "changes" is available here:
https://github.com/bolprocessor/bolprocessor/blob/graphics-for-BP3/BP3-changes.txt

and the installation tutorial (which I am currently updating) is on this 
page:
https://bolprocessor.org/check-bp3/

Well, that was a lot of work! But, as I announced a year ago, I trained 
myself to work with a very efficient and patient partner called 
"ChatGPT". This partner wrote a minimal application called "MIDItest", 
which sends a few notes to a MIDI device. To do this, at my request, he 
created C code that could be compiled for implementation on the three 
platforms: MacOS, Linux and Windows.

I only tried it on MacOS, but I ported all the code to BP3. The source 
code "MIDItest.c" is included in the distribution, along with 
compilation details, so that a Linux or Windows user can check its 
operation, fix the code (possibly with the help of ChatGPT!) and send me 
the updates which I will apply to BP3. By the way, "MIDItest.c" can be 
of great help to programmers who want to implement MIDI output in their 
own applications.

This makes me very optimistic because I know we can use the same method 
to develop other important features such as real-time Csound, Open Sound 
Control, etc.

Real-time MIDI output has a few limitations that I am working on:
1) It sends MIDI messages to the first available MIDI destination. It 
will be easy to design a "MIDI setup" page and store its data in a 
"MIDIsetup.txt" file that the console will read.
2) The STOP button used to interrupt improvisation does not always 
immediately create the "_stop" file that tells the application to stop. 
This is because the browser that handles the interface is almost dead 
while the console is running... This means that an ongoing improvisation 
is often never stopped unless the Apache server is restarted. I need to 
implement another method to send instructions to the console in real time.

In fact, a "stop" command could also be sent as a MIDI message... This 
is why I also plan to implement MIDI input, then restore scripting, etc. 
The algorithmic structure for this is already there, since the BP3 code 
contains remnants of the BP2 code, which was fully interactive with MIDI 
input/output devices.

So, we have taken a significant step! For this reason, the current 
distribution deserves to be named "Bol Processor 3.0" :-)

On Wednesday 15th May at 13:00 GMT (or 15:00 Paris time) I will have a 
zoom meeting with Luciano, which you are welcome to join. It's an open 
discussion, no agenda... Please contact me at be...@bo... 
to get a link to the meeting.

With best regards
Bernard Bel

[bp-dev] A zoom discussion of planned development (PS)

[Bernard B. <ber...@gm...>]

PS. Our zoom meeting on Tuesday 9 April will take place at 13:00 GMT 
(i.e. 3 p.m.  Paris time).
We hope to see you!

Bernard

-------

Dear colleagues,

Recently I had a friendly contact with Luciano, a data engineer and 
software designer based in the Netherlands, which led to an informal 
exchange via Zoom. We decided to communicate every 3 weeks or so to 
discuss upcoming BP3 development issues.

I hope some of you will be able to join us for our next Zoom 
conversation on Tuesday 9 April. Visual/audio communication is conducive 
to creative ideas! Please contact me privately (ber...@gm...) to 
get the link. Don't hesitate to take part in this brainstorming session, 
even if you're not in a position to devote time to further development…

As you will notice on the to-do list:
https://github.com/bolprocessor/bolprocessor/blob/graphics-for-BP3/BP3-To-Do.txt

the same current tasks are pending, perhaps with the highest priority to 
completing the real-time MIDI interface on the console. If a developer 
can write a "minimal" application that sends, say, 3 time-stamped 
NoteOn/NoteOff messages to one MIDI device and receives any MIDI message 
from another device, I will adapt their code and integrate it into the 
BP3 console.

Luciano and I also discussed real-time communication with Csound, which 
requires UDP:
https://csound.com/docs/manual/udpserver.html

We need to go beyond Csound and develop communication with other sound 
systems via Open Sound Control (OSC). My suggestion is the same as for 
real-time MIDI: write a very small application in C and allow it to 
capture and send messages to/from other devices. I  will take care of 
integrating the code into BP3.

Regarding the "compilation" of the PHP/Javascript interface, Czarek 
Tomczak told me late last year that he has resumed work on the MacOS 
version of PHP Desktop (https://github.com/cztomczak/phpdesktop). This 
is a separate issue that I can handle on my own.

Don't forget that the project is also open to companies wishing to 
invest in the funding of short-term coding jobs with the further 
intention of products incorporating Bol Processor components.

I hope to hear from you soon!

With best regards
Bernard Bel

[bp-dev] A zoom discussion of planned development

[Bernard B. <ber...@gm...>]

Dear colleagues,

Recently I had a friendly contact with Luciano, a data engineer and 
software designer based in the Netherlands, which led to an informal 
exchange via Zoom. We decided to communicate every 3 weeks or so to 
discuss upcoming BP3 development issues.

I hope some of you will be able to join us for our next Zoom 
conversation on Tuesday 9 April. Visual/audio communication is conducive 
to creative ideas! Please contact me privately (ber...@gm...) to 
get the link. Don't hesitate to take part in this brainstorming session, 
even if you're not in a position to devote time to further development…

As you will notice on the to-do list:
https://github.com/bolprocessor/bolprocessor/blob/graphics-for-BP3/BP3-To-Do.txt

the same current tasks are pending, perhaps with the highest priority to 
completing the real-time MIDI interface on the console. If a developer 
can write a "minimal" application that sends, say, 3 time-stamped 
NoteOn/NoteOff messages to one MIDI device and receives any MIDI message 
from another device, I will adapt their code and integrate it into the 
BP3 console.

Luciano and I also discussed real-time communication with Csound, which 
requires UDP:
https://csound.com/docs/manual/udpserver.html

We need to go beyond Csound and develop communication with other sound 
systems via Open Sound Control (OSC). My suggestion is the same as for 
real-time MIDI: write a very small application in C and allow it to 
capture and send messages to/from other devices. I  will take care of 
integrating the code into BP3.

Regarding the "compilation" of the PHP/Javascript interface, Czarek 
Tomczak told me late last year that he has resumed work on the MacOS 
version of PHP Desktop (https://github.com/cztomczak/phpdesktop). This 
is a separate issue that I can handle on my own.

Don't forget that the project is also open to companies wishing to 
invest in the funding of short-term coding jobs with the further 
intention of products incorporating Bol Processor components.

I hope to hear from you soon!

With best regards
Bernard Bel

[bp-dev] My talk for Native Instruments, and more ideas

[Bernard B. <ber...@gm...>]

Dear colleagues,

On 15th November I gave a Tech Talk for Native Instruments 
(https://www.native-instruments.com) on the Bol Processor project in its 
historical, musicological and computational aspects. I was invited by 
Campbell Payne, who suggested a 50-minute talk.

Needless to say, I felt anxious about speaking in English (which is not 
used in my village!), but after a long preparation with slides, I 
managed to do it without too many mistakes… Then I edited the video, 
which is now on YouTube:
https://www.youtube.com/watch?v=jLHzKUQKLPY

Your "likes" and comments are very welcome!

In offline discussions with key participants, I realised that probably 
the most urgent task in BP3's development will be the completion of its 
real-time MIDI output/input driver. This would allow it to be used in 
continuous improvisation with real-time control of rule weights and 
flags, as was the case with the earlier BP2 version. This approach is 
known as "live coding".

I have also seen interest in the microtonal tunings I have demonstrated 
in the context of tuning schemes used for baroque instrumental music. I 
am in contact with the Entonal Studio project (https://entonal.studio/), 
which is doing on MIDI what we are doing on Csound. Indeed, their 
methods of constructing scales are different, but I think it would be 
great to offer both versions: the numerical/algorithmic and the 
empirical/sensory.

I also notice that we can do much more with MIDI in terms of tuning 
individual notes, thanks to environments like ODDSOUND 
(https://oddsound.com/devs.php).

These are interesting perspectives, given the lack of Csound expertise.

Please don't hesitate to share this video. I am convinced that it will 
help us to register more participants, developers and musicians…

Bernard Bel

[bp-dev] ChatGPT is working with us!

[Bernard B. <ber...@gm...>]

Dear colleagues,

I haven't communicated for a long time... The main reason is that I'm 
trying to recruit new (active) contributors to this project. To this 
end, I have contacted dozens of programmers/musicians/academics via my 
LinkedIn network. The response has often been very positive, although so 
far none of my contacts has taken the initiative to participate in the 
development of the Bol Processor. My guess is that most of the competent 
people are busy looking for (paid) jobs, or busy with other projects, 
and the only people who could afford to work with us are (like me) old 
programmers who do not feel like investing time in new technology. :-(

So… Suddenly I had the idea of hiring a new programmer who would 
certainly tick all the boxes for effective participation... This is 
ChatGPT!!! I had tried this platform for information search - very often 
with wrong results, even invented, as very bad students do. But I saw 
that it could also be asked to write code.

So I thought of the most urgent problem on BP3: to finish the 
implementation of MIDI in real time. Something abominable in my mind, 
but surely it can be solved simply by a programmer familiar with this 
environment.

So I asked the following question... I haven't tried this code yet, but 
it seems to be very meaningful, and most likely we can get it to do what 
is needed in BP3 — though the input won't be a text file. If necessary, 
ask more questions to our "colleague" ChatGPT!

Here it goes:

-------
QUESTION: Please write C code reading the name of a musical note (and 
its octave number) from a text file and producing a message that will be 
sent in real time to a MIDI device. Use CoreMIDI driver for this, and 
include the code setting up CoreMIDI driver.

-------
ANSWER: To read the name of a musical note and its octave number from a 
text file, you can use the standard C library functions to open, read, 
and close a file. Here's an example code that reads a note and its 
octave from a file named "note.txt":

-------
#include <stdio.h>
#include <stdlib.h>
#include <CoreMIDI/CoreMIDI.h>

int main()
{
     // Set up CoreMIDI driver
     MIDIClientRef midiClient;
     MIDIClientCreate(CFSTR("MIDI Client"), NULL, NULL, &midiClient);

     MIDIPortRef midiOutPort;
     MIDIOutputPortCreate(midiClient, CFSTR("MIDI Output Port"), 
&midiOutPort);

     // Open file
     FILE *file;
     file = fopen("note.txt", "r");
     if (file == NULL) {
         printf("Error opening file.\n");
         exit(1);
     }

     // Read note and octave
     char note;
     int octave;
     fscanf(file, "%c%d", &note, &octave);

     // Convert note and octave to MIDI note and send message to device
     int midiNote = (octave + 1) * 12; // Middle C is MIDI note 60
     switch (note) {
         case 'C': midiNote += 0; break;
         case 'D': midiNote += 2; break;
         case 'E': midiNote += 4; break;
         case 'F': midiNote += 5; break;
         case 'G': midiNote += 7; break;
         case 'A': midiNote += 9; break;
         case 'B': midiNote += 11; break;
         default: printf("Invalid note.\n"); exit(1);
     }

     MIDIPacketList packetList;
     MIDIPacketListInit(&packetList);
     MIDIPacket *packet = MIDIPacketListAdd(&packetList, 
sizeof(packetList), NULL, 0, 3, NULL);
     packet->data[0] = 0x90; // Note on
     packet->data[1] = midiNote;
     packet->data[2] = 127; // Velocity
     packet->timeStamp = 0;
     MIDISend(midiOutPort, NULL, &packetList);

     // Close file and clean up CoreMIDI
     fclose(file);
     MIDIPortDispose(midiOutPort);
     MIDIClientDispose(midiClient);

     return 0;
}

-------
This code assumes that the text file "note.txt" contains a single line 
with a note and its octave number, separated by a space, like this: "C4" 
or "A5". The code converts the note and octave to a MIDI note number and 
sends a MIDI "Note On" message with a velocity of 127 to the default 
MIDI device.
-------