use DesktopAudio version 1.0

import Generators


module Test {
	ports: [
		mainOutputPort OutputPort {
			block: Output
		}
		mainInputPort InputPort {
			block: Input
		}
		propertyInputPort TestPort {
			name: "test"
			block: TestBlock
		}
	]
	streams: [
		Input * TestBlock >> Output;
		]
}

signal Half {default: 0.5}
signal Quarter {default: 0.25}

AudioIn[1] >> Test(test: Half) >> AudioOut[1];
AudioIn[2] >> Test(test: Quarter) >> AudioOut[2];



===========================================================



#include "RtAudio.h"
#include <iostream>
#include <cstdlib>
#include <cstring>


//[[Includes]]
//[[/Includes]]


//[[Declarations]]










class Test {
public:
    float TestBlock;
    float Output;
    float Input;

    Test() {
        TestBlock = 0;
        Output = 0;
        Input = 0;

    }
    void process__TestPortDomain(float TestBlock, float &_BridgeSig_1) {
        // Starting stream 01 -------------------------
//#line 20 "/home/andres/Documents/src/Stride/Stride/strideroot/frameworks/RtAudio/1.0/_tests/module/04a_port_signal.stride"
        _BridgeSig_1 = TestBlock;
// Stream End 01
    }
    void process__OutputDomain_0(float _BridgeSig_0_Input, float _BridgeSig_1, float &Output) {
        // Starting stream 02 -------------------------
        Output = (_BridgeSig_0_Input * _BridgeSig_1);
// Stream End 02
    }
    void process__InputDomain_0(float Input, float &_BridgeSig_0_Input) {
        // Starting stream 00 -------------------------
//#line 20 "/home/andres/Documents/src/Stride/Stride/strideroot/frameworks/RtAudio/1.0/_tests/module/04a_port_signal.stride"
        _BridgeSig_0_Input = Input;
// Stream End 00
    }

};
float Half;
float _BridgeSig_2_Half;
float AudioIn[2];
float _Test_026_out;
Test Test_026;
float AudioOut[2];
float Quarter;
float _BridgeSig_3_Quarter;
float _Test_069_out;
Test Test_069;
float Test_026_Output;
float Test_069_Output;
float Test_026_Input;
float Test_026__BridgeSig_0_Input;
float Test_069_Input;
float Test_069__BridgeSig_0_Input;
float Test_026_TestBlock;
float Test_026__BridgeSig_1;
float Test_069_TestBlock;
float Test_069__BridgeSig_1;
#include <RtAudio.h>
#define NUM_IN_CHANNELS 2
#define NUM_OUT_CHANNELS 2
typedef float MY_TYPE;
#define FORMAT RTAUDIO_FLOAT32
//[[/Declarations]]

//[[Instances]]
//[[/Instances]]


//[[Processing]]

int audio_buffer_process( void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,
                          double streamTime, RtAudioStreamStatus status, void *data )
{
    if ( status ) std::cout << "Stream over/underflow detected." << std::endl;
    //unsigned long *bytes = (unsigned long *) data;
    MY_TYPE *in = (MY_TYPE *)inputBuffer;
    MY_TYPE *out = (MY_TYPE *)outputBuffer;
    while(nBufferFrames-- > 0) {
// Starting stream 00 -------------------------
//#line 27 "/home/andres/Documents/src/Stride/Stride/strideroot/frameworks/RtAudio/1.0/_tests/module/04a_port_signal.stride"
        _BridgeSig_2_Half = Half;
// Stream End 00
// Starting stream 01 -------------------------
//#line 27 "/home/andres/Documents/src/Stride/Stride/strideroot/frameworks/RtAudio/1.0/_tests/module/04a_port_signal.stride"
        AudioIn[0] = in[0];
        Test_026.process__InputDomain_0(AudioIn[0], Test_026__BridgeSig_0_Input);
        Test_026.process__TestPortDomain(_BridgeSig_2_Half, Test_026__BridgeSig_1);
        Test_026.process__OutputDomain_0(Test_026__BridgeSig_0_Input, Test_026__BridgeSig_1, _Test_026_out);
        out[0] = _Test_026_out;;
// Stream End 01
// Starting stream 02 -------------------------
//#line 28 "/home/andres/Documents/src/Stride/Stride/strideroot/frameworks/RtAudio/1.0/_tests/module/04a_port_signal.stride"
        _BridgeSig_3_Quarter = Quarter;
// Stream End 02
// Starting stream 03 -------------------------
//#line 28 "/home/andres/Documents/src/Stride/Stride/strideroot/frameworks/RtAudio/1.0/_tests/module/04a_port_signal.stride"
        AudioIn[1] = in[1];
        Test_069.process__InputDomain_0(AudioIn[1], Test_069__BridgeSig_0_Input);
        Test_069.process__TestPortDomain(_BridgeSig_3_Quarter, Test_069__BridgeSig_1);
        Test_069.process__OutputDomain_0(Test_069__BridgeSig_0_Input, Test_069__BridgeSig_1, _Test_069_out);
        out[1] = _Test_069_out;;
// Stream End 03
        in += NUM_IN_CHANNELS;
        out += NUM_OUT_CHANNELS;
    }
    return 0;
}
//[[/Processing]]

//[[OSC:Processing]]
//[[/OSC:Processing]]
//[[SerialIn:Processing]]
//[[/SerialIn:Processing]]
//[[SerialOut:Processing]]
//[[/SerialOut:Processing]]


int main() {
//[[Initialization]]






    Half = 0.5;
    _BridgeSig_2_Half = 0.5;
    AudioIn[0] = 0.0;
    AudioIn[1] = 0.0;
    AudioOut[0] = 0.0;
    AudioOut[1] = 0.0;
    Quarter = 0.25;
    _BridgeSig_3_Quarter = 0.25;
    Test_026_Output = 0;
    Test_069_Output = 0;
    Test_026_Input = 0;
    Test_026__BridgeSig_0_Input = 0;
    Test_069_Input = 0;
    Test_069__BridgeSig_0_Input = 0;
    Test_026_TestBlock = 0;
    Test_026__BridgeSig_1 = 0;
    Test_069_TestBlock = 0;
    Test_069__BridgeSig_1 = 0;

    RtAudio adac;
    if ( adac.getDeviceCount() < 1 ) {
        std::cout << std::endl << "No audio devices found!" << std::endl;
        exit( -1 );
    }
    // Set the same number of channels for both input and output.
    unsigned int bufferBytes;
    unsigned int bufferFrames = 512;
    int iDevice = 0;
    int oDevice = 0;
    unsigned int fs = 44100;


    RtAudio::StreamOptions options;
    //options.flags |= RTAUDIO_NONINTERLEAVED;

    RtAudio::StreamParameters iParams, oParams;
    iParams.deviceId = 0; // first available device
    iParams.nChannels = 2;
    oParams.deviceId = 0; // first available device
    oParams.nChannels = 2;

    bufferBytes = bufferFrames * NUM_OUT_CHANNELS * sizeof( MY_TYPE );

    if ( iDevice == 0 )
        iParams.deviceId = adac.getDefaultInputDevice();
    if ( oDevice == 0 )
        oParams.deviceId = adac.getDefaultOutputDevice();
    try {
        adac.openStream( &oParams, &iParams, FORMAT, fs, &bufferFrames, &audio_buffer_process, (void *)&bufferBytes, &options);
    }
    catch ( RtAudioError& e ) {
        e.printMessage();
        exit( -1 );
    }
    RtAudio::DeviceInfo info = adac.getDeviceInfo(0);
    std::cout << "Device = " << 0 << std::endl;
    std::cout << "Name = " << info.name << std::endl;
    std::cout << ": maximum output channels = " << info.outputChannels << std::endl;
    try {
        adac.startStream();
    }
    catch ( RtAudioError& e ) {
        e.printMessage();
        if ( adac.isStreamOpen() ) adac.closeStream();
        exit (-1);
    }
    char input;
    std::cout << "\nRunning ... press <enter> to quit.\n";
    std::cin.get(input);

//[[/Initialization]]

// char input;
// std::cout << "\nRunning ... press <enter> to quit.\n";
// std::cin.get(input);

//[[Cleanup]]

    // Stop the stream.
    try {
        if ( adac.isStreamRunning() ) adac.stopStream();
        if ( adac.isStreamOpen() ) adac.closeStream();
    }
    catch ( RtAudioError& e ) {
        e.printMessage();
    }

//[[/Cleanup]]


    return 0;
}