//std::audio example 1 "single process"
void example_1{
    double sample_rate = 44100;
    std::size_t frame_size =2;
    std::size_t buffer_size=128;

    std::audio_context<float> ctx{sample_rate,buffer_size,frame_size};//contruct from values

    std::astream_process<float> proc(ctx,[](std::iastream const& input, std::oastream& output){
        std::frame_buffer<float>& buff = ctx.borrow_buffer();//borrow a buffer from the context for usage
        //prevents the need for dynamic allocation of a temporary buffer
        input>>buff;//stream data into buffer for manipulation
        for(auto&& frame: buff){
            frame=0.0;//do something with audio
        }
        output<<buff;//stream to output
    });//dsp object
    //uses implied routing equivilent to
    //std::aout<<proc<<std::ain;
    //

    proc.start();
    //do other stuff
    proc.stop();
}

//std::audio example 2 "process group"
void example_2{

    std::audio_context<float> ctx;//default context created with std::default_* values

    //version 1: capture context via lambda
    std::astream_process<float> proc1(ctx,[&ctx](std::iastream const& input, std::oastream& output){
        std::frame_buffer<float>& buff = ctx.borrow_buffer();
        input>>buff;
        for(auto&& frame: buff){
            frame*=0.5;
        }
        output<<buff;
    });//dsp object

    //version 2: have context passed as argument
    std::astream_process<float> proc2(ctx,[](std::iastream const& input, std::oastream& output,std::audio_context<float> const& context){
        std::frame_buffer<float>& buff = ctx.borrow_buffer();
        input>>buff;
        for(auto&& frame: buff){
            frame*=2.0;
        }
        output<<buff;
    });

    std::process_group<float> pgroup;//a group of processes that will happen consecutivley
    pgroup.push(proc1);//add to group
    pgroup.push(proc2);//add to group

    //configure stream relationships in terms of std::ain / std:aout manually
    //std::ain/std::aout are std::astream globals that refer to the default audio inputs and outputs supplied by the context in use
    //std::ain/std::aout will route the audio to the enpoint specified by the context reference held by the process that is streaming the data
    std::aout<<proc1<<proc2<<std::ain;//method 1
    //std::ain>>proc2>>proc1>>std::aout;//method 2

    pgroup.start();
    //do other stuff
    pgroup.stop();

}


//std::audio example 3 "audio files"
void example_3{

    std::audio_context<float> ctx;

    std::astream_process<float> proc(ctx,[](std::iafstream const& input, std::oafstream& output){
        std::frame_buffer<float>& buff = ctx.borrow_buffer();
        input>>buff;
        for(auto&& frame: buff){
            frame=0.0;
        }
        output<<buff;
    });//dsp object

    std::iafstream audio_file1(ctx,"filename1.extension");//an audio file handle
    std::oafstream audio_file2(ctx,"filename2.extension");//an audio file handle

    //routing
    audio_file2<<proc<<audio_file1;//take input from file nad write to file
    //audio_file1>>proc>>audio_file2;//equivilent syntax
    proc.start();
    //do other stuff
    proc.stop();
}


//std::audio example 4 "combination routing"
void example_3{

    std::audio_context<float> ctx;
    //manually select hardware endpoints
    std::size_t device_id = ctx.default_device_id();
    std::iastream input_device = ctx.get_device<std::input_device>(device_id);
    std::oastream output_device = ctx.get_device<std::output_device>(device_id);

    std::astream_process<float> proc(ctx,[](std::iastream const& input,
                                            std::oastream& output,
                                            std::iafstream const& input_file,
                                             std::oafstream& output_file){
        std::frame_buffer<float>& buff = ctx.borrow_buffer();
        (input + input_file)>>buff;//add streams to perform sum before writing to buffer
        //or you could use seperate buffers
        //like this
        /*
            std::frame_buffer<float> buff1;
            std::frame_buffer<float> buff2;

            input>>buff1;
            input_file>>buff2;
            buff1+=buff2;//buffer arithmatic
        */
        output<<buff;//send the contents of buff to the hardware out and the file out
        output_file<<buff;
    });

    std::iafstream audio_file1(ctx,"filename1.extension");//the actual files to be used above
    std::oafstream audio_file2(ctx,"filename2.extension");

    //connect the files to the process
    //connect the hardware device to the process
    audio_file2<<proc<<audio_file1;//take input from file
    output_device<<proc<<input_device;//also take from hardware
    proc.start();
    //do other stuff
    proc.stop();
}