Wow. That's a nice read!

On 8 April 2013 21:47, john ffitch <jpff@codemist.co.uk> wrote:
> The developer team are relieved to announce that we have completed a
> release candidate 1 of csound6.  As ever treat with caution, but if
> you have time and energy please test.
>
> Sources and an OSX binary are on Sourceforge now.  Instead of a
> Release Note file there is a What_is_New.txt document, reproduced
> below.
>
> All being well we will be moving to a real release soon.
>
> ==John ffitch
> ========================================================================
>
> WHAT NEEDS HEAVY TESTING
> ========================
>
> Multiple strings in score
>
> --sample-accurate
>
> Arrays
>
>
> What is New, What has Changed
> =============================
>
> Build system in cmake (and not scons as in Csound5).
>
>
> The loadable opcodes are found in the directory named in the
> environment variables OPCODE6DIR64 or OPCODE6DIR (note the 6) so it
> can co-exist with Csound5
>
>
> Support for old hardware and C compilers has been removed; this
> includes Macintosh OS9 and earlier, Watcom, Borland and Symmantec C
> compilers.
>
>
>
> Note events can start and end in mid-kcycle.  As this is an
> incompatible change it is only invoked with the command-line option
>     --sample-accurate
> is specified.  Not that this does not work for tied notes, and use of
> skipping initialisation has questionable use.
>
>
>
> A number of table access opcodes have been rewritten but should behave
> the same.  Similarly diskin and diskin2 now use the same code and so
> diskin should be more stable
>
>
>
> Compilation can be done at any stage, new instruments are added or
> replace old ones. Running instances of old instrument definitions are
> not affected. Only limitation is that instr0 is only compiled once, in
> the first compilation.
>
> Two i-time opcodes for compilation:
> ires  compileorc   ifilename
> compiles an orchestra in ifilename (instr0 ignored)
>
> ires  compilestr    Sinstruments
> compiles an orchestra defined in Sinstruments
>
> ires is 0 if successful and non-0 if compilation failed.
>
>
>
>
> The old parser is totally gone.
>
>
>
> New syntax in csound6 includes +=, -=, *= and /= operators
> Please use += and -= for accumulating reverbs as it gives better
> multicore behaviour.
>
>
>
>
> Multicore support is totally rewritten using a different algorithm for
> task-dispatch, which should use less memory and fewer locks.
>
>
>
> Opcodes like add, sub, mul and div are no longer available in opcode
> format, only via + - * /
>
>
>
> Any opcode that returns one answer and whose type is the same as the
> first argument can be used as a function.  This incorporates all
> functions in CS5, but also functions of two arguments such as taninv2
> and divz, and opcodes like oscil.
>
>
> A statement can be broken across lines after a , = or arithmetic
> operation.
>
>
> Arrays exist in multidimensional format.  They are created (usually)
> with init opcode.
>   k1[]  init 4
> generates a k-rate 1-D array of length 4.  Similarly
>   a2[][] init 4,4
> create a square 4x4 a-rate array.
> Elements are used via indexing in [] such as k1[2] or a2[2][3]
> One dimensional arrays replace tvars, and can be used in opcodes like
> maxtab, mintab and sumtab. Array setting can be done in left-hand side
> of opcodes, i.e.:
>   aSigs[0] vco2 .1, 440
>   aSigs[1] vco2 .1, 880
>
>
>
> The new realtime priority mode can be switched on with by passing the
> --realtime or setting the CSOUND_PARAMS field realtime_mode to 1.
>
> This has the following effects:
> 1) all opcode audio file reading/writing is handled asynchronously by
> a separate thread
> 2) all init-pass operations are also performed asynchronously.
>
>
>
> Functions for asynchronous audio file access have been added (see
> below)
>
>
>
> Analysis formats:
> Hetro/adsyn analysis files can be machine byte-order independent if
> created with -X.  Down side is a longer file and a little slower
> loading.  The het_export utility will create the independent format
> from the old, and het_import is no longer necessary.
>
> cvanal and lpanal will produce machine independent files if -X option
> is used.  The convolve and lpread etc opcodes will accept either
> format.  You are encouraged to use the machine independent form.
> Analysis files produced with -X can be used on other systems.
>
>
>
> The number of strings that can be used in a score line is no longer
> just one.  It is open ended.
>
>
>
> Each instance of any instrument has a scratchpad of 4 values that
> persist; allows values to carry to next use of the instrument; hope it
> may be useful in legato etc.
>
>
>
> If a table number is given as -1 then an internal sine wave equivalent
> to "f. 0 8192 10 1" is used.  Attempts to write to this table will
> give unpredictable results, but is not policed.  The 8192 can be
> change by command line option --sine-size=# where the # is rounded up
> to a power of two.
>
>
> New API functions.....
>
>     new configuration/parameter setting functions
>     PUBLIC int csoundSetOption(CSOUND *csound, char *option);
>     PUBLIC void csoundSetParams(CSOUND *csound, CSOUND_PARAMS *p);
>     PUBLIC void csoundGetParams(CSOUND *csound, CSOUND_PARAMS *p);
>     PUBLIC void csoundSetOutput(CSOUND *csound, char *name, char *type,
>                                 char *format);
>     PUBLIC void csoundSetInput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIInput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIFileInput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIOutput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIFileOutput(CSOUND *csound, char *name);
>
>     new parsing/compilation functions
>     PUBLIC TREE *csoundParseOrc(CSOUND *csound, char *str);
>     PUBLIC int csoundCompileTree(CSOUND *csound, TREE *root);
>     PUBLIC int csoundCompileOrc(CSOUND *csound, char *str);
>     PUBLIC int csoundReadScore(CSOUND *csound, char *str);
>     PUBLIC int csoundCompileArgs(CSOUND *, int argc, char **argv);
>
>     new function for starting csound after first compilation
>     PUBLIC int csoundStart(CSOUND *csound);
>
>     new software bus threadsafe getters/setters
>     PUBLIC MYFLT csoundGetControlChannel(CSOUND *csound, const char *name);
>     PUBLIC void csoundSetControlChannel(CSOUND *csound, const char *name,
>                                         MYFLT val);
>     PUBLIC void csoundGetAudioChannel(CSOUND *csound, const char *name,
>                                       MYFLT *samples);
>     PUBLIC void csoundSetAudioChannel(CSOUND *csound, const char *name,
>                                       MYFLT *samples);
>     PUBLIC void csoundSetStringChannel(CSOUND *csound, const char *name,
>                                        char *string);
>     PUBLIC  void csoundGetStringChannel(CSOUND *csound, const char  *name,
>                                         char *string);
>
>     new table threadsafe copy functions
>     PUBLIC void csoundTableCopyOut(CSOUND *csound, int table, MYFLT *dest);
>     PUBLIC void csoundTableCopyIn(CSOUND *csound, int table, MYFLT *src);
>
>     API has been made threadsafe so that performance and control can
>     occur in separate threads (after a call to csoundStart() or
>     csoundCompile()). Threadsafety is ensure by 1) use of atomic
>     read/writing to control channels 2) spinlocks in audio and string
>     channels 3) mutexes protecting compilation, score events and table access
>
> Invalue/outvalue and channel callbacks and callback setters have been removed.
> csoundQueryInterface() has been removed
>
> New internal functions in CSOUND:
>
>     void (*FlushCircularBuffer)(CSOUND *, void *);
>      flush circular buffer.
>     void *(*FileOpenAsync)(CSOUND *, void *, int, const char *, void *,
>                            const char *, int, int, int);
>     unsigned int (*ReadAsync)(CSOUND *, void *, MYFLT *, int);
>     unsigned int (*WriteAsync)(CSOUND *, void *, MYFLT *, int);
>     int  (*FSeekAsync)(CSOUND *, void *, int, int);
>       async file access.
>     char *(*GetString)(CSOUND *, MYFLT);
>        Extract a string originating from a score-event argument.
>
> functions removed
>     void *(*FileOpen)(CSOUND *,
>                       void*, int, const char*, void*, const char*);
>
> The "private" parts of the API have been changed considerably.  Also
> structures like EVTBLK have changed
>
>
>
> The LINKAGE1/FLINKAGE1 macros are renamed as LINKAGE_BUILTIN/FLINKAGE_BUILTIN
>
>
>
> Template for arate perf-pass opcodes is
> ------------------------------------------------------------------------
> int perf_myopcode(CSOUND *csound, MYOPCODE *p)
> {
>     uint32_t offset = p->h.insdshead->ksmps_offset;
>     uint32_t early  = p->h.insdshead->ksmps_no_end;
>     uint32_t nsmps = CS_KSMPS;
>     ...
>     if (UNLIKELY(offset)) memset(p->res, '\0', offset*sizeof(MYFLT));
>     if (UNLIKELY(early))  {
>       nsmps -= early;
>       memset(&p->res[nsmps], '\0', early*sizeof(MYFLT));
>     }
>     for (n=offset; n<nsmps; n++) {
>         .....
>         p->res[n] = ....
>     }
>     return OK;
> }
> ------------------------------------------------------------------------
>
>
> for opcode developers.....
>
> TECHNICAL CHANGES
> =================
>
> OENTRY structure has changed and has a new dependency field; please
> use this field as it is required for multicore semantics.  You could
> set it to -1 and disallow all parallelism, but at least it is safe.
>
> All opcodes that touch audio should take note of sample-accurate code
>
> A number of previous API functions are removed; OpenFile and OpenFile2
> both replaced by new OpenFile2 with additional argument.
>
> Additions have been made for arg type specifications for opcodes.
>   * Any-types have been added, as follows:
>     * '.' signifies a required arg of any-type
>     * '?' signifies an optional arg of any-type
>     * '*' signifies a var-arg list of any-type
>   * Arrays are now specified using "[x]" where x is a type-specifier.
>     The type-specifier can be any of the of the current specifiers,
>     including any-types.  See Opcodes/arrays.c for example usage.
>
> New Type System
> ===============
> A new type system has been added to Csound6, and significant changes
> have been made to the compiler. The previous system for handling types
> involved depending on the first-letter of a variable's name every time
> it was used to determine type. This meant there was a lot of re-checking
> of types. Also, adding new types was difficult, as there was a lot of
> custom code that had to be updated to check for new type letters.
>
> In Csound6, a separate system of types was added.  Types are defined as
> CS_TYPE's.  The creation of variables from types and the initialisation
> of memory has been encapsulated within the CS_TYPE's. This change
> allows easier addition of new types, as well as generic calculations of
> memory pools, amongst other things.
>
> The compiler has been modified since Csound5 to now use the type system
> as an integral part of its semantic checking phase.  Variables are now
> registered into a CS_VAR_POOL when they are first defined, with the
> CS_VARIABLE having a reference to its CS_TYPE.  After first time
> definition within the pool, the type information is then looked up in
> consequent variable lookups, rather than re-calculated from the variable
> name.  This opens up possibilities for new variable naming and typing
> strategies, i.e. using "myVar:K" to denote a k-rate arg.  This also
> opens up possibilities for user-defined types, such as
> "data myType kval, aval", then using "myVar:myType" to define a var
> of that type.  (The previous is speculative, and is not an active
> proposal at this time.)
>
> The addition of the type system has formalised the static type system
> that has existed in Csound prior to Csound6. It has, arguably, simplified
> the code-base in terms of type handling, as well as laid the ground work
> for future type-related research to be integrated into Csound.
>
>
>
>
> Send bugs reports to the Sourceforge bug tracker
>             https://sourceforge.net/tracker/?group_id=81968&atid=564599
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"
>


Send bugs reports to the Sourceforge bug tracker
            https://sourceforge.net/tracker/?group_id=81968&atid=564599
Discussions of bugs and features can be posted here
To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"

The developer team are relieved to announce that we have completed a
release candidate 1 of csound6.  As ever treat with caution, but if
you have time and energy please test.

Sources and an OSX binary are on Sourceforge now.  Instead of a
Release Note file there is a What_is_New.txt document, reproduced
below.

All being well we will be moving to a real release soon.

==John ffitch
========================================================================

WHAT NEEDS HEAVY TESTING
========================

Multiple strings in score

--sample-accurate

Arrays


What is New, What has Changed
=============================

Build system in cmake (and not scons as in Csound5).


The loadable opcodes are found in the directory named in the
environment variables OPCODE6DIR64 or OPCODE6DIR (note the 6) so it
can co-exist with Csound5


Support for old hardware and C compilers has been removed; this
includes Macintosh OS9 and earlier, Watcom, Borland and Symmantec C
compilers.



Note events can start and end in mid-kcycle.  As this is an
incompatible change it is only invoked with the command-line option
    --sample-accurate
is specified.  Not that this does not work for tied notes, and use of
skipping initialisation has questionable use.



A number of table access opcodes have been rewritten but should behave
the same.  Similarly diskin and diskin2 now use the same code and so
diskin should be more stable



Compilation can be done at any stage, new instruments are added or
replace old ones. Running instances of old instrument definitions are
not affected. Only limitation is that instr0 is only compiled once, in
the first compilation.

Two i-time opcodes for compilation:
ires  compileorc   ifilename
compiles an orchestra in ifilename (instr0 ignored)

ires  compilestr    Sinstruments
compiles an orchestra defined in Sinstruments

ires is 0 if successful and non-0 if compilation failed.




The old parser is totally gone.



New syntax in csound6 includes +=, -=, *= and /= operators
Please use += and -= for accumulating reverbs as it gives better
multicore behaviour.




Multicore support is totally rewritten using a different algorithm for
task-dispatch, which should use less memory and fewer locks.



Opcodes like add, sub, mul and div are no longer available in opcode
format, only via + - * /



Any opcode that returns one answer and whose type is the same as the
first argument can be used as a function.  This incorporates all
functions in CS5, but also functions of two arguments such as taninv2
and divz, and opcodes like oscil.


A statement can be broken across lines after a , = or arithmetic
operation.


Arrays exist in multidimensional format.  They are created (usually)
with init opcode.
  k1[]  init 4
generates a k-rate 1-D array of length 4.  Similarly
  a2[][] init 4,4
create a square 4x4 a-rate array.
Elements are used via indexing in [] such as k1[2] or a2[2][3]
One dimensional arrays replace tvars, and can be used in opcodes like
maxtab, mintab and sumtab. Array setting can be done in left-hand side
of opcodes, i.e.:
  aSigs[0] vco2 .1, 440
  aSigs[1] vco2 .1, 880



The new realtime priority mode can be switched on with by passing the
--realtime or setting the CSOUND_PARAMS field realtime_mode to 1.

This has the following effects:
1) all opcode audio file reading/writing is handled asynchronously by
a separate thread
2) all init-pass operations are also performed asynchronously.



Functions for asynchronous audio file access have been added (see
below)



Analysis formats:
Hetro/adsyn analysis files can be machine byte-order independent if
created with -X.  Down side is a longer file and a little slower
loading.  The het_export utility will create the independent format
from the old, and het_import is no longer necessary.

cvanal and lpanal will produce machine independent files if -X option
is used.  The convolve and lpread etc opcodes will accept either
format.  You are encouraged to use the machine independent form.
Analysis files produced with -X can be used on other systems.



The number of strings that can be used in a score line is no longer
just one.  It is open ended.



Each instance of any instrument has a scratchpad of 4 values that
persist; allows values to carry to next use of the instrument; hope it
may be useful in legato etc.



If a table number is given as -1 then an internal sine wave equivalent
to "f. 0 8192 10 1" is used.  Attempts to write to this table will
give unpredictable results, but is not policed.  The 8192 can be
change by command line option --sine-size=# where the # is rounded up
to a power of two.


New API functions.....

    new configuration/parameter setting functions
    PUBLIC int csoundSetOption(CSOUND *csound, char *option);
    PUBLIC void csoundSetParams(CSOUND *csound, CSOUND_PARAMS *p);
    PUBLIC void csoundGetParams(CSOUND *csound, CSOUND_PARAMS *p);
    PUBLIC void csoundSetOutput(CSOUND *csound, char *name, char *type,
                                char *format);
    PUBLIC void csoundSetInput(CSOUND *csound, char *name);
    PUBLIC void csoundSetMIDIInput(CSOUND *csound, char *name);
    PUBLIC void csoundSetMIDIFileInput(CSOUND *csound, char *name);
    PUBLIC void csoundSetMIDIOutput(CSOUND *csound, char *name);
    PUBLIC void csoundSetMIDIFileOutput(CSOUND *csound, char *name);

    new parsing/compilation functions
    PUBLIC TREE *csoundParseOrc(CSOUND *csound, char *str);
    PUBLIC int csoundCompileTree(CSOUND *csound, TREE *root);
    PUBLIC int csoundCompileOrc(CSOUND *csound, char *str);
    PUBLIC int csoundReadScore(CSOUND *csound, char *str);
    PUBLIC int csoundCompileArgs(CSOUND *, int argc, char **argv);

    new function for starting csound after first compilation
    PUBLIC int csoundStart(CSOUND *csound);

    new software bus threadsafe getters/setters
    PUBLIC MYFLT csoundGetControlChannel(CSOUND *csound, const char *name);
    PUBLIC void csoundSetControlChannel(CSOUND *csound, const char *name,
                                        MYFLT val);
    PUBLIC void csoundGetAudioChannel(CSOUND *csound, const char *name,
                                      MYFLT *samples);
    PUBLIC void csoundSetAudioChannel(CSOUND *csound, const char *name,
                                      MYFLT *samples);
    PUBLIC void csoundSetStringChannel(CSOUND *csound, const char *name,
                                       char *string);
    PUBLIC  void csoundGetStringChannel(CSOUND *csound, const char  *name,
                                        char *string);

    new table threadsafe copy functions
    PUBLIC void csoundTableCopyOut(CSOUND *csound, int table, MYFLT *dest);
    PUBLIC void csoundTableCopyIn(CSOUND *csound, int table, MYFLT *src);

    API has been made threadsafe so that performance and control can
    occur in separate threads (after a call to csoundStart() or
    csoundCompile()). Threadsafety is ensure by 1) use of atomic
    read/writing to control channels 2) spinlocks in audio and string
    channels 3) mutexes protecting compilation, score events and table access

Invalue/outvalue and channel callbacks and callback setters have been removed.
csoundQueryInterface() has been removed

New internal functions in CSOUND:

    void (*FlushCircularBuffer)(CSOUND *, void *);
     flush circular buffer.
    void *(*FileOpenAsync)(CSOUND *, void *, int, const char *, void *,
                           const char *, int, int, int);
    unsigned int (*ReadAsync)(CSOUND *, void *, MYFLT *, int);
    unsigned int (*WriteAsync)(CSOUND *, void *, MYFLT *, int);
    int  (*FSeekAsync)(CSOUND *, void *, int, int);
      async file access.
    char *(*GetString)(CSOUND *, MYFLT);
       Extract a string originating from a score-event argument.

functions removed
    void *(*FileOpen)(CSOUND *,
                      void*, int, const char*, void*, const char*);

The "private" parts of the API have been changed considerably.  Also
structures like EVTBLK have changed



The LINKAGE1/FLINKAGE1 macros are renamed as LINKAGE_BUILTIN/FLINKAGE_BUILTIN



Template for arate perf-pass opcodes is
------------------------------------------------------------------------
int perf_myopcode(CSOUND *csound, MYOPCODE *p)
{
    uint32_t offset = p->h.insdshead->ksmps_offset;
    uint32_t early  = p->h.insdshead->ksmps_no_end;
    uint32_t nsmps = CS_KSMPS;
    ...
    if (UNLIKELY(offset)) memset(p->res, '\0', offset*sizeof(MYFLT));
    if (UNLIKELY(early))  {
      nsmps -= early;
      memset(&p->res[nsmps], '\0', early*sizeof(MYFLT));
    }
    for (n=offset; n<nsmps; n++) {
        .....
        p->res[n] = ....
    }
    return OK;
}
------------------------------------------------------------------------


for opcode developers.....

TECHNICAL CHANGES
=================

OENTRY structure has changed and has a new dependency field; please
use this field as it is required for multicore semantics.  You could
set it to -1 and disallow all parallelism, but at least it is safe.

All opcodes that touch audio should take note of sample-accurate code

A number of previous API functions are removed; OpenFile and OpenFile2
both replaced by new OpenFile2 with additional argument.

Additions have been made for arg type specifications for opcodes.
  * Any-types have been added, as follows:
    * '.' signifies a required arg of any-type
    * '?' signifies an optional arg of any-type
    * '*' signifies a var-arg list of any-type
  * Arrays are now specified using "[x]" where x is a type-specifier.
    The type-specifier can be any of the of the current specifiers,
    including any-types.  See Opcodes/arrays.c for example usage.

New Type System
===============
A new type system has been added to Csound6, and significant changes
have been made to the compiler. The previous system for handling types
involved depending on the first-letter of a variable's name every time
it was used to determine type. This meant there was a lot of re-checking
of types. Also, adding new types was difficult, as there was a lot of
custom code that had to be updated to check for new type letters.

In Csound6, a separate system of types was added.  Types are defined as
CS_TYPE's.  The creation of variables from types and the initialisation
of memory has been encapsulated within the CS_TYPE's. This change
allows easier addition of new types, as well as generic calculations of
memory pools, amongst other things.

The compiler has been modified since Csound5 to now use the type system
as an integral part of its semantic checking phase.  Variables are now
registered into a CS_VAR_POOL when they are first defined, with the
CS_VARIABLE having a reference to its CS_TYPE.  After first time
definition within the pool, the type information is then looked up in
consequent variable lookups, rather than re-calculated from the variable
name.  This opens up possibilities for new variable naming and typing
strategies, i.e. using "myVar:K" to denote a k-rate arg.  This also
opens up possibilities for user-defined types, such as
"data myType kval, aval", then using "myVar:myType" to define a var
of that type.  (The previous is speculative, and is not an active
proposal at this time.)

The addition of the type system has formalised the static type system
that has existed in Csound prior to Csound6. It has, arguably, simplified
the code-base in terms of type handling, as well as laid the ground work
for future type-related research to be integrated into Csound.




Send bugs reports to the Sourceforge bug tracker
            https://sourceforge.net/tracker/?group_id=81968&atid=564599
Discussions of bugs and features can be posted here
To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"

oolala!

On 8 April 2013 21:54, Rory Walsh <rorywalsh@ear.ie> wrote:

Wow. That's a nice read!

On 8 April 2013 21:47, john ffitch <jpff@codemist.co.uk> wrote:
> The developer team are relieved to announce that we have completed a
> release candidate 1 of csound6.  As ever treat with caution, but if
> you have time and energy please test.
>
> Sources and an OSX binary are on Sourceforge now.  Instead of a
> Release Note file there is a What_is_New.txt document, reproduced
> below.
>
> All being well we will be moving to a real release soon.
>
> ==John ffitch
> ========================================================================
>
> WHAT NEEDS HEAVY TESTING
> ========================
>
> Multiple strings in score
>
> --sample-accurate
>
> Arrays
>
>
> What is New, What has Changed
> =============================
>
> Build system in cmake (and not scons as in Csound5).
>
>
> The loadable opcodes are found in the directory named in the
> environment variables OPCODE6DIR64 or OPCODE6DIR (note the 6) so it
> can co-exist with Csound5
>
>
> Support for old hardware and C compilers has been removed; this
> includes Macintosh OS9 and earlier, Watcom, Borland and Symmantec C
> compilers.
>
>
>
> Note events can start and end in mid-kcycle.  As this is an
> incompatible change it is only invoked with the command-line option
>     --sample-accurate
> is specified.  Not that this does not work for tied notes, and use of
> skipping initialisation has questionable use.
>
>
>
> A number of table access opcodes have been rewritten but should behave
> the same.  Similarly diskin and diskin2 now use the same code and so
> diskin should be more stable
>
>
>
> Compilation can be done at any stage, new instruments are added or
> replace old ones. Running instances of old instrument definitions are
> not affected. Only limitation is that instr0 is only compiled once, in
> the first compilation.
>
> Two i-time opcodes for compilation:
> ires  compileorc   ifilename
> compiles an orchestra in ifilename (instr0 ignored)
>
> ires  compilestr    Sinstruments
> compiles an orchestra defined in Sinstruments
>
> ires is 0 if successful and non-0 if compilation failed.
>
>
>
>
> The old parser is totally gone.
>
>
>
> New syntax in csound6 includes +=, -=, *= and /= operators
> Please use += and -= for accumulating reverbs as it gives better
> multicore behaviour.
>
>
>
>
> Multicore support is totally rewritten using a different algorithm for
> task-dispatch, which should use less memory and fewer locks.
>
>
>
> Opcodes like add, sub, mul and div are no longer available in opcode
> format, only via + - * /
>
>
>
> Any opcode that returns one answer and whose type is the same as the
> first argument can be used as a function.  This incorporates all
> functions in CS5, but also functions of two arguments such as taninv2
> and divz, and opcodes like oscil.
>
>
> A statement can be broken across lines after a , = or arithmetic
> operation.
>
>
> Arrays exist in multidimensional format.  They are created (usually)
> with init opcode.
>   k1[]  init 4
> generates a k-rate 1-D array of length 4.  Similarly
>   a2[][] init 4,4
> create a square 4x4 a-rate array.
> Elements are used via indexing in [] such as k1[2] or a2[2][3]
> One dimensional arrays replace tvars, and can be used in opcodes like
> maxtab, mintab and sumtab. Array setting can be done in left-hand side
> of opcodes, i.e.:
>   aSigs[0] vco2 .1, 440
>   aSigs[1] vco2 .1, 880
>
>
>
> The new realtime priority mode can be switched on with by passing the
> --realtime or setting the CSOUND_PARAMS field realtime_mode to 1.
>
> This has the following effects:
> 1) all opcode audio file reading/writing is handled asynchronously by
> a separate thread
> 2) all init-pass operations are also performed asynchronously.
>
>
>
> Functions for asynchronous audio file access have been added (see
> below)
>
>
>
> Analysis formats:
> Hetro/adsyn analysis files can be machine byte-order independent if
> created with -X.  Down side is a longer file and a little slower
> loading.  The het_export utility will create the independent format
> from the old, and het_import is no longer necessary.
>
> cvanal and lpanal will produce machine independent files if -X option
> is used.  The convolve and lpread etc opcodes will accept either
> format.  You are encouraged to use the machine independent form.
> Analysis files produced with -X can be used on other systems.
>
>
>
> The number of strings that can be used in a score line is no longer
> just one.  It is open ended.
>
>
>
> Each instance of any instrument has a scratchpad of 4 values that
> persist; allows values to carry to next use of the instrument; hope it
> may be useful in legato etc.
>
>
>
> If a table number is given as -1 then an internal sine wave equivalent
> to "f. 0 8192 10 1" is used.  Attempts to write to this table will
> give unpredictable results, but is not policed.  The 8192 can be
> change by command line option --sine-size=# where the # is rounded up
> to a power of two.
>
>
> New API functions.....
>
>     new configuration/parameter setting functions
>     PUBLIC int csoundSetOption(CSOUND *csound, char *option);
>     PUBLIC void csoundSetParams(CSOUND *csound, CSOUND_PARAMS *p);
>     PUBLIC void csoundGetParams(CSOUND *csound, CSOUND_PARAMS *p);
>     PUBLIC void csoundSetOutput(CSOUND *csound, char *name, char *type,
>                                 char *format);
>     PUBLIC void csoundSetInput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIInput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIFileInput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIOutput(CSOUND *csound, char *name);
>     PUBLIC void csoundSetMIDIFileOutput(CSOUND *csound, char *name);
>
>     new parsing/compilation functions
>     PUBLIC TREE *csoundParseOrc(CSOUND *csound, char *str);
>     PUBLIC int csoundCompileTree(CSOUND *csound, TREE *root);
>     PUBLIC int csoundCompileOrc(CSOUND *csound, char *str);
>     PUBLIC int csoundReadScore(CSOUND *csound, char *str);
>     PUBLIC int csoundCompileArgs(CSOUND *, int argc, char **argv);
>
>     new function for starting csound after first compilation
>     PUBLIC int csoundStart(CSOUND *csound);
>
>     new software bus threadsafe getters/setters
>     PUBLIC MYFLT csoundGetControlChannel(CSOUND *csound, const char *name);
>     PUBLIC void csoundSetControlChannel(CSOUND *csound, const char *name,
>                                         MYFLT val);
>     PUBLIC void csoundGetAudioChannel(CSOUND *csound, const char *name,
>                                       MYFLT *samples);
>     PUBLIC void csoundSetAudioChannel(CSOUND *csound, const char *name,
>                                       MYFLT *samples);
>     PUBLIC void csoundSetStringChannel(CSOUND *csound, const char *name,
>                                        char *string);
>     PUBLIC  void csoundGetStringChannel(CSOUND *csound, const char  *name,
>                                         char *string);
>
>     new table threadsafe copy functions
>     PUBLIC void csoundTableCopyOut(CSOUND *csound, int table, MYFLT *dest);
>     PUBLIC void csoundTableCopyIn(CSOUND *csound, int table, MYFLT *src);
>
>     API has been made threadsafe so that performance and control can
>     occur in separate threads (after a call to csoundStart() or
>     csoundCompile()). Threadsafety is ensure by 1) use of atomic
>     read/writing to control channels 2) spinlocks in audio and string
>     channels 3) mutexes protecting compilation, score events and table access
>
> Invalue/outvalue and channel callbacks and callback setters have been removed.
> csoundQueryInterface() has been removed
>
> New internal functions in CSOUND:
>
>     void (*FlushCircularBuffer)(CSOUND *, void *);
>      flush circular buffer.
>     void *(*FileOpenAsync)(CSOUND *, void *, int, const char *, void *,
>                            const char *, int, int, int);
>     unsigned int (*ReadAsync)(CSOUND *, void *, MYFLT *, int);
>     unsigned int (*WriteAsync)(CSOUND *, void *, MYFLT *, int);
>     int  (*FSeekAsync)(CSOUND *, void *, int, int);
>       async file access.
>     char *(*GetString)(CSOUND *, MYFLT);
>        Extract a string originating from a score-event argument.
>
> functions removed
>     void *(*FileOpen)(CSOUND *,
>                       void*, int, const char*, void*, const char*);
>
> The "private" parts of the API have been changed considerably.  Also
> structures like EVTBLK have changed
>
>
>
> The LINKAGE1/FLINKAGE1 macros are renamed as LINKAGE_BUILTIN/FLINKAGE_BUILTIN
>
>
>
> Template for arate perf-pass opcodes is
> ------------------------------------------------------------------------
> int perf_myopcode(CSOUND *csound, MYOPCODE *p)
> {
>     uint32_t offset = p->h.insdshead->ksmps_offset;
>     uint32_t early  = p->h.insdshead->ksmps_no_end;
>     uint32_t nsmps = CS_KSMPS;
>     ...
>     if (UNLIKELY(offset)) memset(p->res, '\0', offset*sizeof(MYFLT));
>     if (UNLIKELY(early))  {
>       nsmps -= early;
>       memset(&p->res[nsmps], '\0', early*sizeof(MYFLT));
>     }
>     for (n=offset; n<nsmps; n++) {
>         .....
>         p->res[n] = ....
>     }
>     return OK;
> }
> ------------------------------------------------------------------------
>
>
> for opcode developers.....
>
> TECHNICAL CHANGES
> =================
>
> OENTRY structure has changed and has a new dependency field; please
> use this field as it is required for multicore semantics.  You could
> set it to -1 and disallow all parallelism, but at least it is safe.
>
> All opcodes that touch audio should take note of sample-accurate code
>
> A number of previous API functions are removed; OpenFile and OpenFile2
> both replaced by new OpenFile2 with additional argument.
>
> Additions have been made for arg type specifications for opcodes.
>   * Any-types have been added, as follows:
>     * '.' signifies a required arg of any-type
>     * '?' signifies an optional arg of any-type
>     * '*' signifies a var-arg list of any-type
>   * Arrays are now specified using "[x]" where x is a type-specifier.
>     The type-specifier can be any of the of the current specifiers,
>     including any-types.  See Opcodes/arrays.c for example usage.
>
> New Type System
> ===============
> A new type system has been added to Csound6, and significant changes
> have been made to the compiler. The previous system for handling types
> involved depending on the first-letter of a variable's name every time
> it was used to determine type. This meant there was a lot of re-checking
> of types. Also, adding new types was difficult, as there was a lot of
> custom code that had to be updated to check for new type letters.
>
> In Csound6, a separate system of types was added.  Types are defined as
> CS_TYPE's.  The creation of variables from types and the initialisation
> of memory has been encapsulated within the CS_TYPE's. This change
> allows easier addition of new types, as well as generic calculations of
> memory pools, amongst other things.
>
> The compiler has been modified since Csound5 to now use the type system
> as an integral part of its semantic checking phase.  Variables are now
> registered into a CS_VAR_POOL when they are first defined, with the
> CS_VARIABLE having a reference to its CS_TYPE.  After first time
> definition within the pool, the type information is then looked up in
> consequent variable lookups, rather than re-calculated from the variable
> name.  This opens up possibilities for new variable naming and typing
> strategies, i.e. using "myVar:K" to denote a k-rate arg.  This also
> opens up possibilities for user-defined types, such as
> "data myType kval, aval", then using "myVar:myType" to define a var
> of that type.  (The previous is speculative, and is not an active
> proposal at this time.)
>
> The addition of the type system has formalised the static type system
> that has existed in Csound prior to Csound6. It has, arguably, simplified
> the code-base in terms of type handling, as well as laid the ground work
> for future type-related research to be integrated into Csound.
>
>
>
>
> Send bugs reports to the Sourceforge bug tracker
>             https://sourceforge.net/tracker/?group_id=81968&atid=564599
> Discussions of bugs and features can be posted here
> To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"
>


Send bugs reports to the Sourceforge bug tracker
            https://sourceforge.net/tracker/?group_id=81968&atid=564599
Discussions of bugs and features can be posted here
To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"