package main

/*
#cgo pkg-config: portaudio-2.0
#include <portaudio.h>
#include <pa.h>
*/
import "C"

import (
	"fmt"
	"time"
	"unsafe"
	_ "os"
	_ "runtime"
	"reflect"
)

var (
inputParameters = new(C.PaStreamParameters)
stream = new(C.PaStream)
)

// DeviceInfo contains information for an audio device.
type DeviceInfo struct {
	index                    C.PaDeviceIndex
	Name                     string
	MaxInputChannels         int
	MaxOutputChannels        int
	DefaultLowInputLatency   time.Duration
	DefaultLowOutputLatency  time.Duration
	DefaultHighInputLatency  time.Duration
	DefaultHighOutputLatency time.Duration
	DefaultSampleRate        float64
}

type Stream struct {
	paStream            unsafe.Pointer
	inParams, outParams *C.PaStreamParameters
	in, out             *reflect.SliceHeader
	args                []reflect.Value
	callback            reflect.Value
	closed              bool
}

func main() {

	if err:=C.Pa_Initialize();err != C.paNoError {
		fmt.Println(err)
	}
	defer func(){
		if err := C.Pa_Terminate();err != C.paNoError {
			fmt.Println(err )
		}

		}()

	inputParameters.device = C.Pa_GetDefaultInputDevice(); /* default input device */
	if (inputParameters.device == C.paNoDevice) {
				fmt.Println("Error: No default input device.")
	}
	inputParameters.channelCount = 1
	inputParameters.sampleFormat = C.paFloat32
  inputParameters.suggestedLatency = C.Pa_GetDeviceInfo( inputParameters.device ).defaultLowInputLatency
  inputParameters.hostApiSpecificStreamInfo = nil

stream:=&Stream{}
		err := C.Pa_OpenStream(
                 &stream.paStream,
                 inputParameters,
                 nil,                  /* &outputParameters, */
                 C.double(44100),
                 C.paFramesPerBufferUnspecified,
                 C.paClipOff,      /* we won't output out of range samples so don't bother clipping them */
                 C.paStreamWrap,
                 unsafe.Pointer(stream.paStream) );
       if( err != C.paNoError ) {
				 fmt.Println(err)
				 }

       ;
       if err := C.Pa_StartStream( unsafe.Pointer(stream.paStream) ); err != C.paNoError {
				 fmt.Println(err)
				 }


			 for x:=0;x<20;x++{
				 time.Sleep(1*time.Second)
				//  x:=C.Pa_IsStreamActive(unsafe.Pointer(stream))

				//  fmt.Println(x)
			 }
      //  while( ( err = Pa_IsStreamActive( stream ) ) == 1 )
      //  {
      //      Pa_Sleep(1000);
      //      printf("index = %d\n", data.frameIndex ); fflush(stdout);
      //  }

}

func duration(paTime C.PaTime) time.Duration {
	return time.Duration(paTime * C.PaTime(time.Second))
}

//export streamCallback
func streamCallback(inputBuffer, outputBuffer unsafe.Pointer, frames C.ulong, timeInfo *C.PaStreamCallbackTimeInfo, statusFlags C.PaStreamCallbackFlags, userData unsafe.Pointer) {
	fmt.Println("called")
}





>>>>>>>>>>>>>>>>>>>>>>>>>>>>
// pa.h file


int cb(const void *inputBuffer, void *outputBuffer, unsigned long frames, const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData);
PaStreamCallback* paStreamWrap;





>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
//pa.c file


#include <portaudio.h>

int cb(const void *inputBuffer, void *outputBuffer, unsigned long frames, const PaStreamCallbackTimeInfo *timeInfo, PaStreamCallbackFlags statusFlags, void *userData) {
	streamCallback((void*)inputBuffer, outputBuffer, frames, (PaStreamCallbackTimeInfo*)timeInfo, statusFlags, userData);
	return paContinue;
}
PaStreamCallback* paStreamWrap = cb;

# command-line-arguments
duplicate symbol _paStreamWrap in:
    $WORK/command-line-arguments/_obj/_cgo_export.o
    $WORK/command-line-arguments/_obj/pa.cgo2.o
ld: 1 duplicate symbol for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)