void
PortAudioLayer::initStream()
{
dcblocker_.reset();
RING_DBG("Open PortAudio Output Stream");
PaStreamParameters outputParameters;
outputParameters.device = indexOut_;
if (outputParameters.device == paNoDevice) {
RING_ERR("Error: No valid output device. There will be no sound.");
} else {
const auto outputDeviceInfo =
Pa_GetDeviceInfo(outputParameters.device);
outputParameters.channelCount =
audioFormat_.nb_channels = outputDeviceInfo->maxOutputChannels;
outputParameters.sampleFormat = paInt16;
outputParameters.suggestedLatency = outputDeviceInfo->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
auto err = Pa_OpenStream(
&streams[Direction::Output],
NULL,
&outputParameters,
outputDeviceInfo->defaultSampleRate,
paFramesPerBufferUnspecified,
paNoFlag,
&PortAudioLayer::paOutputCallback,
this);
if(err != paNoError)
this->handleError(err);
}
RING_DBG("Open PortAudio Input Stream");
PaStreamParameters inputParameters;
inputParameters.device = indexIn_;
if (inputParameters.device == paNoDevice) {
RING_ERR("Error: No valid input device. There will be no mic.");
} else {
const auto inputDeviceInfo =
Pa_GetDeviceInfo(inputParameters.device);
inputParameters.channelCount =
audioInputFormat_.nb_channels = inputDeviceInfo->maxInputChannels;
inputParameters.sampleFormat = paInt16;
inputParameters.suggestedLatency = inputDeviceInfo->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
auto err = Pa_OpenStream(
&streams[Direction::Input],
&inputParameters,
NULL,
inputDeviceInfo->defaultSampleRate,
paFramesPerBufferUnspecified,
paNoFlag,
&PortAudioLayer::paInputCallback,
this);
if(err != paNoError)
this->handleError(err);
}
RING_DBG("Start PortAudio Streams");
for (int i = 0; i < Direction::End; i++) {
auto err = Pa_StartStream(streams[i]);
if (err != paNoError)
this->handleError(err);
}
flushUrgent();
flushMain();
}
static int output_data(char *buf, int32 nbytes)
{
unsigned int i;
int32 samplesToGo;
char *bufepoint;
if(pa_active == 0) return -1;
while((pa_active==1) && (pa_data.samplesToGo > bytesPerInBuffer)){ Pa_Sleep(1);};
// if(pa_data.samplesToGo > DATA_BLOCK_SIZE){
// Sleep( (pa_data.samplesToGo - DATA_BLOCK_SIZE)/dpm.rate/4 );
// }
samplesToGo=pa_data.samplesToGo;
bufepoint=pa_data.bufepoint;
if (pa_data.buf+bytesPerInBuffer*2 >= bufepoint + nbytes){
memcpy(bufepoint, buf, nbytes);
bufepoint += nbytes;
//buf += nbytes;
}else{
int32 send = pa_data.buf+bytesPerInBuffer*2 - bufepoint;
if (send != 0) memcpy(bufepoint, buf, send);
buf += send;
memcpy(pa_data.buf, buf, nbytes - send);
bufepoint = pa_data.buf + nbytes - send;
//buf += nbytes-send;
}
samplesToGo += nbytes;
pa_data.samplesToGo=samplesToGo;
pa_data.bufepoint=bufepoint;
/*
if(firsttime==1){
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
firsttime=0;
}
*/
#if PORTAUDIO_V19
if( 0==Pa_IsStreamActive(stream)){
#else
if( 0==Pa_StreamActive(stream)){
#endif
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
}
// if(ctl->id_character != 'r' && ctl->id_character != 'A' && ctl->id_character != 'W' && ctl->id_character != 'P')
// while((pa_active==1) && (pa_data.samplesToGo > bytesPerInBuffer)){ Pa_Sleep(1);};
// Pa_Sleep( (pa_data.samplesToGo - bytesPerInBuffer)/dpm.rate * 1000);
return 0;
error:
Pa_Terminate(); pa_active=0;
ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "PortAudio error: %s\n", Pa_GetErrorText( err ) );
return -1;
}
static void close_output(void)
{
if( pa_active==0) return;
#ifdef PORTAUDIO_V19
if(Pa_IsStreamActive(stream)){
#else
if(Pa_StreamActive(stream)){
#endif
Pa_Sleep( bytesPerInBuffer/dpm.rate*1000 );
}
err = Pa_AbortStream( stream );
if( (err!=paStreamIsStopped) && (err!=paNoError) ) goto error;
err = Pa_CloseStream( stream );
// if( err != paNoError ) goto error;
Pa_Terminate();
pa_active=0;
#ifdef AU_PORTAUDIO_DLL
#ifndef PORTAUDIO_V19
free_portaudio_dll();
#endif
#endif
return;
error:
Pa_Terminate(); pa_active=0;
#ifdef AU_PORTAUDIO_DLL
#ifndef PORTAUDIO_V19
free_portaudio_dll();
#endif
#endif
ctl->cmsg( CMSG_ERROR, VERB_NORMAL, "PortAudio error: %s\n", Pa_GetErrorText( err ) );
return;
}
static int acntl(int request, void *arg)
{
switch(request)
{
case PM_REQ_GETQSIZ:
*(int *)arg = bytesPerInBuffer*2;
return 0;
//break;
case PM_REQ_GETFILLABLE:
*(int *)arg = bytesPerInBuffer*2-pa_data.samplesToGo;
return 0;
//break;
case PM_REQ_GETFILLED:
*(int *)arg = pa_data.samplesToGo;
return 0;
//break;
case PM_REQ_DISCARD:
case PM_REQ_FLUSH:
pa_data.samplesToGo=0;
pa_data.bufpoint=pa_data.bufepoint;
err = Pa_AbortStream( stream );
if( (err!=paStreamIsStopped) && (err!=paNoError) ) goto error;
err = Pa_StartStream( stream );
if(err!=paNoError) goto error;
return 0;
//break;
case PM_REQ_RATE:
{
int i;
double sampleRateBack;
i = *(int *)arg; //* sample rate in and out *
close_output();
sampleRateBack=dpm.rate;
dpm.rate=i;
if(0==open_output()){
return 0;
}else{
dpm.rate=sampleRateBack;
open_output();
return -1;
}
}
//break;
// case PM_REQ_RATE:
// return -1;
case PM_REQ_PLAY_START: //* Called just before playing *
case PM_REQ_PLAY_END: //* Called just after playing *
return 0;
default:
return -1;
}
return -1;
error:
/*
Pa_Terminate(); pa_active=0;
#ifdef AU_PORTAUDIO_DLL
free_portaudio_dll();
#endif
*/
ctl->cmsg( CMSG_ERROR, VERB_NORMAL, "PortAudio error in acntl : %s\n", Pa_GetErrorText( err ) );
return -1;
}
static void print_device_list(void){
PaDeviceIndex maxDeviceIndex, i;
PaHostApiIndex HostApiIndex;
const PaDeviceInfo* DeviceInfo;
#if PORTAUDIO_V19
HostApiIndex=Pa_HostApiTypeIdToHostApiIndex(HostApiTypeId);
#endif
maxDeviceIndex=Pa_GetDeviceCount();
for( i = 0; i < maxDeviceIndex; i++){
DeviceInfo=Pa_GetDeviceInfo(i);
#if PORTAUDIO_V19
if( DeviceInfo->hostApi == HostApiIndex){
#endif
if( DeviceInfo->maxOutputChannels > 0){
ctl->cmsg( CMSG_ERROR, VERB_NORMAL, "%2d %s",i,DeviceInfo->name);
}
#if PORTAUDIO_V19
}
#endif
}
}
int run_filter(AudioOptions audio_options)
{
PaStreamParameters input_parameters, output_parameters;
PaStream *input_stream = NULL, *output_stream = NULL;
PaError err = paNoError;
CircularBuffer * output_buffer = CircularBuffer_create(audio_options.buffer_size);
CircularBuffer * input_buffer = NULL;
CircularBuffer * decoder_input = NULL;
DecodingBuffer * decoder_buffer = NULL;
int live_stream = !audio_options.wav_path || !strlen(audio_options.wav_path);
OSFilter * filter =
OSFilter_create(
audio_options.filters,
audio_options.num_filters,
2,
audio_options.filter_size,
audio_options.conv_multiple * (audio_options.filter_size - 1),
audio_options.input_scale
);
if (!filter) {
goto done;
}
if ((err = Pa_Initialize()) != paNoError) {
goto done;
}
int step_size = audio_options.filter_size - 1;
RecordCallbackMetadata record_data = {
NULL,
0,
0,
audio_options.number_of_channels,
audio_options.enabled_channels,
0
};
{
int num_enabled_channels = 0;
for (int i = 0; i < audio_options.number_of_channels; ++i) {
if (audio_options.enabled_channels & (1 << i)) {
num_enabled_channels++;
}
}
if (num_enabled_channels != audio_options.enabled_channels) {
record_data.stripe_input = 1;
}
if (num_enabled_channels == 0) {
record_data.stripe_input = 0;
}
}
if (record_data.stripe_input) {
printf("striping record_data: %d channels with %d enabled flag\n",
record_data.number_of_channels,
record_data.enabled_channels
);
} else {
printf("NOT striping record_data: %d channels with %d enabled flag\n",
record_data.number_of_channels,
record_data.enabled_channels
);
}
if (live_stream) {
input_buffer = CircularBuffer_create(audio_options.buffer_size);
if (audio_options.decode_input) {
decoder_input = CircularBuffer_create(audio_options.buffer_size);
decoder_buffer = Decoding_new(decoder_input, input_buffer);
record_data.buffer = decoder_input;
if (!Decoding_start_ac3(decoder_buffer)) {
printf("Failed to start ac3 decoder thread.\n");
goto done;
}
} else {
record_data.buffer = input_buffer;
}
input_parameters.device = audio_options.input_device;
input_parameters.channelCount = 2;
input_parameters.sampleFormat = PA_SAMPLE_TYPE;
input_parameters.suggestedLatency = Pa_GetDeviceInfo(input_parameters.device)->defaultHighInputLatency;
input_parameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&input_stream,
&input_parameters,
NULL,
audio_options.sample_rate,
step_size,
paNoFlag,
recordCallback,
&record_data
);
if (err != paNoError) {
goto done;
}
record_data.start_time = currentTimeMillis();
#ifdef LINUX_ALSA
PaAlsa_EnableRealtimeScheduling(input_stream, 1);
#endif
if ((err = Pa_StartStream(input_stream)) != paNoError) {
goto done;
}
} else {
input_buffer = __read_audio_file(audio_options);
}
output_parameters.device = audio_options.output_device;
if (audio_options.output_channels >= 6) {
output_parameters.channelCount = audio_options.output_channels + 2;
} else {
output_parameters.channelCount = audio_options.output_channels;
}
output_parameters.sampleFormat = PA_SAMPLE_TYPE;
output_parameters.suggestedLatency = Pa_GetDeviceInfo(output_parameters.device)->defaultLowOutputLatency;
output_parameters.hostApiSpecificStreamInfo = NULL;
PlaybackCallbackData playback_data = {
output_buffer,
output_parameters.channelCount
};
printf("output channels: %d\n", output_parameters.channelCount);
err = Pa_OpenStream(
&output_stream,
NULL,
&output_parameters,
audio_options.sample_rate,
step_size,
paNoFlag,
playCallback,
&playback_data
);
if (err != paNoError) {
goto done;
}
#ifdef LINUX_ALSA
PaAlsa_EnableRealtimeScheduling(output_stream, 1);
#endif
if ((err = Pa_StartStream(output_stream)) != paNoError) {
goto done;
}
int output_scale = output_parameters.channelCount / 2;
int frame_print_interval = DEBUG_PRINT_INTERVAL_MILLIS * audio_options.sample_rate / 1000;
int current_frame = 0;
while (true) {
if ((err = Pa_IsStreamActive(output_stream)) != 1) {
break;
}
if (input_stream && (err = Pa_IsStreamActive(input_stream)) != 1) {
break;
}
current_frame += OSFilter_execute(filter, input_buffer, output_buffer);
if (audio_options.print_debug && current_frame > frame_print_interval) {
current_frame -= frame_print_interval;
if (!is_parent_running(audio_options.parent_thread_ident)) {
printf("Parent thread is dead. Shutting down now.\n");
fflush(stdout);
goto done;
}
if (!audio_options.print_debug) {
continue;
}
long frame_difference = (CircularBuffer_lag(input_buffer) + CircularBuffer_lag(output_buffer) / output_scale) / 2;
float lag = (float)(frame_difference) / audio_options.sample_rate * 1000;
printf("%lu\t%lu\t%lu\t%fms\n",
input_buffer->offset_producer,
output_buffer->offset_consumer / output_scale,
frame_difference, lag
);
if (live_stream && (lag > audio_options.lag_reset_limit * 1000)) {
printf("Resetting to latest due to high lag.\n");
CircularBuffer_fastforward(input_buffer, audio_options.filter_size * 2);
CircularBuffer_fastforward(output_buffer, 0);
}
fflush(stdout);
}
}
if (err < 0) {
goto done;
}
done:
if (output_stream) {
Pa_CloseStream(output_stream);
}
if (input_stream) {
Pa_CloseStream(input_stream);
}
Pa_Terminate();
if (input_buffer) {
CircularBuffer_destroy(input_buffer);
}
CircularBuffer_destroy(output_buffer);
if (decoder_input) {
CircularBuffer_destroy(decoder_input);
}
if (decoder_buffer) {
Decoding_free(decoder_buffer);
}
OSFilter_destroy(filter);
if (err != paNoError) {
fprintf(stdout, "An error occured while using the portaudio stream\n");
fprintf(stdout, "Error number: %d\n", err);
fprintf(stdout, "Error message: %s\n", Pa_GetErrorText(err));
fflush(stdout);
err = 1;
}
return err;
}
int main(int argc, char* argv[])
{
PaStream *stream;
PaError err;
patest1data data;
int i;
PaStreamParameters inputParameters, outputParameters;
const PaHostErrorInfo* herr;
printf("patest1.c\n"); fflush(stdout);
printf("Ring modulate input for 20 seconds.\n"); fflush(stdout);
/* initialise sinusoidal wavetable */
for( i=0; i<100; i++ )
data.sine[i] = sin( ((double)i/100.) * M_PI * 2. );
data.phase = 0;
data.sampsToGo = SAMPLE_RATE * 20; /* 20 seconds. */
/* initialise portaudio subsytem */
err = Pa_Initialize();
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
if (inputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No input default device.\n");
goto done;
}
inputParameters.channelCount = 2; /* stereo input */
inputParameters.sampleFormat = paFloat32; /* 32 bit floating point input */
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto done;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
&inputParameters,
&outputParameters,
(double)SAMPLE_RATE, /* Samplerate in Hertz. */
512, /* Small buffers */
paClipOff, /* We won't output out of range samples so don't bother clipping them. */
patest1Callback,
&data );
if( err != paNoError ) goto done;
err = Pa_StartStream( stream );
if( err != paNoError ) goto done;
printf( "Press any key to end.\n" ); fflush(stdout);
getc( stdin ); /* wait for input before exiting */
err = Pa_AbortStream( stream );
if( err != paNoError ) goto done;
printf( "Waiting for stream to complete...\n" );
/* sleep until playback has finished */
while( ( err = Pa_IsStreamActive( stream ) ) == 1 ) Pa_Sleep(1000);
if( err < 0 ) goto done;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto done;
done:
Pa_Terminate();
if( err != paNoError )
{
fprintf( stderr, "An error occured while using portaudio\n" );
if( err == paUnanticipatedHostError )
{
fprintf( stderr, " unanticipated host error.\n");
herr = Pa_GetLastHostErrorInfo();
if (herr)
{
fprintf( stderr, " Error number: %ld\n", herr->errorCode );
if (herr->errorText)
fprintf( stderr, " Error text: %s\n", herr->errorText );
}
else
fprintf( stderr, " Pa_GetLastHostErrorInfo() failed!\n" );
}
else
{
fprintf( stderr, " Error number: %d\n", err );
fprintf( stderr, " Error text: %s\n", Pa_GetErrorText( err ) );
}
err = 1; /* Always return 0 or 1, but no other return codes. */
}
printf( "bye\n" );
return err;
}
int newChain(PaDeviceIndex inputDeviceIndex, PaDeviceIndex outputDeviceIndex)
{
PaError err;
//malloc memory for new node
Chain* newChain = malloc(sizeof(Chain));
//set new final node's next pointer to NULL
newChain->nextChain = NULL;
if(rootChain == NULL){
rootChain = newChain;
}
else{
Chain* iterator = rootChain;
while(iterator->nextChain != NULL){
iterator = iterator->nextChain;
}
//set final node's next node pointer to new node
iterator->nextChain = newChain;
}
newChain->inputParameters.device = inputDeviceIndex;
if(newChain->inputParameters.device == paNoDevice){
fprintf(stderr,"Error: Input device is invalid.\n Maybe the device has been unplugged?");
goto error;
}
const PaDeviceInfo* inputDeviceInfo = Pa_GetDeviceInfo(inputDeviceIndex);
const PaDeviceInfo* outputDeviceInfo = Pa_GetDeviceInfo(outputDeviceIndex);
newChain->inputParameters.channelCount = inputDeviceInfo->maxInputChannels;
newChain->inputParameters.sampleFormat = PA_SAMPLE_TYPE;
newChain->inputParameters.suggestedLatency = inputDeviceInfo->defaultLowInputLatency;
newChain->inputParameters.hostApiSpecificStreamInfo = NULL;
newChain->outputParameters.device = outputDeviceIndex;
if(newChain->outputParameters.device == paNoDevice){
fprintf(stderr,"Error: Output device is invalid.\n Maybe the device has been unplugged?");
goto error;
}
newChain->outputParameters.channelCount = outputDeviceInfo->maxOutputChannels;
newChain->outputParameters.sampleFormat = PA_SAMPLE_TYPE;
newChain->outputParameters.suggestedLatency = outputDeviceInfo->defaultLowOutputLatency;
newChain->outputParameters.hostApiSpecificStreamInfo = NULL;
//set root ChainLink to empty effect that does nothing, because it needs to be initialized
//to something in order to be passed to the callback
//should probably set this to be a gain adjustment; control output level and input level
newChain->chainLink = malloc(sizeof(ChainLink));
newChain->chainLink->effectType = IO;
newChain->chainLink->effectData = initIOEffect();
newChain->chainLink->effectFunction = &IOEffect;
newChain->chainLink->nextLink = NULL;
//set global number of input and output channels
numInputChannels = newChain->inputParameters.channelCount;
numOutputChannels = newChain->outputParameters.channelCount;
//set the global sampleRate here
sampleRate = inputDeviceInfo->defaultSampleRate;
err = Pa_OpenStream(
&(newChain->stream),
&(newChain->inputParameters),
&(newChain->outputParameters),
inputDeviceInfo->defaultSampleRate,
paFramesPerBufferUnspecified,
paClipOff,
audioCallback,
newChain->chainLink);
if(err != paNoError) goto error;
err = Pa_StartStream(newChain->stream);
if( err != paNoError ) goto error;
return 0;
error:
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
}
bool Initialize(VinoMemory* Mem)
{
// Init values
{
float OrthoMtx[4][4] =
{
{ 2.0f, 0.0f, 0.0f, 0.0f },
{ 0.0f, -2.0f, 0.0f, 0.0f },
{ 0.0f, 0.0f, -1.0f, 0.0f },
{ -1.0f, 1.0f, 0.0f, 1.0f },
};
memcpy(Mem->Window.ProjMtx, OrthoMtx, sizeof(OrthoMtx));
}
#if 0
// Initialize mpg123
{
if (Mem->Audio.Mpg_Init() != MPG123_OK)
{
// TODO: Log error
return false;
}
int Error;
Mem->Audio.MpgHandle = Mem->Audio.Mpg_New(0, &Error);
if (Error)
{
// TODO: Log error
return false;
}
Error = Mem->Audio.Mpg_Open(Mem->Audio.MpgHandle, "C:\\Users\\Apoorva\\Music\\foo.mp3");
if (Error) { return false; }
Error = Mem->Audio.Mpg_GetFormat(Mem->Audio.MpgHandle,
(long*)&Mem->Audio.Rate, &Mem->Audio.Channels, &Mem->Audio.Encoding);
if (Error) { return false; }
}
// Initialize PortAudio
{
PaError Error = Pa_Initialize();
if (Error != paNoError)
{
// TODO: Log: Audio init failure
return false;
}
PaStream* Stream;
Error = Pa_OpenDefaultStream(
&Stream,
0,
Mem->Audio.Channels,
paInt16,
Mem->Audio.Rate,
0,
AudioReadCallback,
Mem);
Error = Pa_SetStreamFinishedCallback(Stream, &AudioFinishedCallback);
if (Error != paNoError) { return false; }
Error = Pa_StartStream(Stream);
if (Error != paNoError) { return false; }
//Error = Pa_StopStream(Stream);
//if (Error != paNoError) { return false; }
//Error = Pa_CloseStream(Stream);
//if (Error != paNoError) { return false; }
//Pa_Terminate();
}
#endif
const char* Vert;
// Vertex shader
{
Vert =
" #version 330 \n"
" uniform mat4 ProjMtx; \n" // Uniforms[0]
" \n"
" in vec2 Position; \n" // Attributes[0]
" in vec2 UV; \n" // Attributes[1]
" in vec4 Color; \n" // Attributes[2]
" \n"
" out vec2 Frag_UV; \n"
" out vec4 Frag_Color; \n"
" void main() \n"
" { \n"
" Frag_UV = UV; \n"
" Frag_Color = Color; \n"
" gl_Position = ProjMtx * vec4(Position.xy,0,1); \n"
" } \n";
}
// Default shader
{
const char* Frag =
" #version 330 \n"
" uniform sampler2D Texture; \n" // Uniforms[1]
" \n"
" in vec2 Frag_UV; \n"
" in vec4 Frag_Color; \n"
" \n"
" out vec4 Out_Color; \n"
" void main() \n"
" { \n"
" Out_Color = Frag_Color * texture( Texture, Frag_UV.st); \n"
" } \n";
CompileShader(Mem->Shaders[VinoShader_Default], Vert, Frag, 3, 2,
"Position", "UV", "Color",
"ProjMtx", "Texture");
}
// Setup for ImGui
{
glGenBuffers(1, &Mem->Meshes[VinoMesh_ImGui].VboHandle);
glGenBuffers(1, &Mem->Meshes[VinoMesh_ImGui].ElementsHandle);
glGenVertexArrays (1, &Mem->Meshes[VinoMesh_ImGui].VaoHandle);
glBindVertexArray (Mem->Meshes[VinoMesh_ImGui].VaoHandle);
glBindBuffer (GL_ARRAY_BUFFER, Mem->Meshes[VinoMesh_ImGui].VboHandle);
glEnableVertexAttribArray(Mem->Shaders[VinoShader_Default].Attributes[0]);
glEnableVertexAttribArray(Mem->Shaders[VinoShader_Default].Attributes[1]);
glEnableVertexAttribArray(Mem->Shaders[VinoShader_Default].Attributes[2]);
#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
glVertexAttribPointer(Mem->Shaders[VinoShader_Default].Attributes[0], 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, pos));
glVertexAttribPointer(Mem->Shaders[VinoShader_Default].Attributes[1], 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, uv));
glVertexAttribPointer(Mem->Shaders[VinoShader_Default].Attributes[2], 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, col));
#undef OFFSETOF
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Create fonts texture
ImGuiIO& io = ImGui::GetIO();
unsigned char* pixels;
int width, height;
//ImFont* my_font0 = io.Fonts->AddFontFromFileTTF("d:\\DroidSans.ttf", 15.0f);
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
glGenTextures (1, &Mem->Textures[VinoTex_Font]);
glBindTexture (GL_TEXTURE_2D, Mem->Textures[VinoTex_Font]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
// Store our identifier
io.Fonts->TexID = (void *)(intptr_t)Mem->Textures[VinoTex_Font];
// Cleanup
io.Fonts->ClearInputData();
io.Fonts->ClearTexData();
}
// Load interface textures and colors
{
// Texture IDs
Mem->Textures[VinoTex_TitleBarButtons] = LoadAndBindImage("../../img/win32_titlebar_buttons.png");
Mem->Textures[VinoTex_TitleBarIcon] = LoadAndBindImage("../../img/win32_titlebar_icon.png");
Mem->Textures[VinoTex_InterfaceIcons] = LoadAndBindImage("../../img/interface_icons.png");
// Colors
#if 1
Mem->Colors[VinoCol_Clear] = Color(45,45,48); // Dark grey
#else
Mem->Colors[VinoCol_Clear] = Color(114,144,154); // Light blue
#endif
Mem->Colors[VinoCol_Transparent] = Color(0,0,0,0);
Mem->Colors[VinoCol_Button] = Color(92,92,94);
Mem->Colors[VinoCol_ButtonHover] = Color(64,64,64);
Mem->Colors[VinoCol_ButtonActive] = Color(0,122,204);
}
// ImGui Style Settings
{
ImGuiStyle& Style = ImGui::GetStyle();
Style.WindowFillAlphaDefault = 1.0f;
// TODO: Move repeated stuff here by setting global style
}
return true;
}
int main(void)
{
PaStreamParameters inputParameters,
outputParameters;
PaStream* stream;
PaError err = paNoError;
paTestData data;
int totalFrames;
int numSamples;
int numBytes;
SAMPLE max, val;
double average;
struct sockaddr_in myaddr, remaddr;
int fd, i, slen=sizeof(remaddr);
char buf[BUFLEN]; /* message buffer */
int recvlen; /* # bytes in acknowledgement message */
char *server = "127.0.0.1"; /* change this to use a different server */
/* create a socket */
if ((fd=socket(AF_INET, SOCK_DGRAM, 0))==-1)
printf("socket created\n");
/* bind it to all local addresses and pick any port number */
memset((char *)&myaddr, 0, sizeof(myaddr));
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
myaddr.sin_port = htons(0);
if (bind(fd, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0) {
perror("bind failed");
return 0;
}
/* now define remaddr, the address to whom we want to send messages */
/* For convenience, the host address is expressed as a numeric IP address */
/* that we will convert to a binary format via inet_aton */
memset((char *) &remaddr, 0, sizeof(remaddr));
remaddr.sin_family = AF_INET;
remaddr.sin_port = htons(SERVICE_PORT);
if (inet_aton(server, &remaddr.sin_addr)==0) {
fprintf(stderr, "inet_aton() failed\n");
exit(1);
}
data.fd = fd;
data.remaddr = (struct sockaddr *) &remaddr;
data.slen = slen;
err = Pa_Initialize();
if( err != paNoError ) exit(1);
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
if (inputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default input device.\n");
exit(1);
}
inputParameters.channelCount = 2; /* stereo input */
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
/* Record some audio. -------------------------------------------- */
err = Pa_OpenStream(
&stream,
&inputParameters,
NULL, /* &outputParameters, */
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
sendCallback,
&data );
if( err != paNoError ) exit(1);
err = Pa_StartStream( stream );
if( err != paNoError ) exit(1);
printf("\n=== Now listenning!! Please speak into the microphone. ===\n"); fflush(stdout);
while( ( err = Pa_IsStreamActive( stream ) ) == 1 )
{
Pa_Sleep(1000);
printf("index = \n"); fflush(stdout);
}
if( err < 0 ) exit(1);
err = Pa_CloseStream( stream );
if( err != paNoError ) exit(1);
/* now let's send the messages */
//close(fd);
return 0;
}
void audiosource_portaudio::init() {
err = Pa_Initialize();
if( err != paNoError ) {
std::cerr << "PortAudio error: " << Pa_GetErrorText( err ) << std::endl;
throw audiosourceexception("Pa_Initialize");
}
PaHostApiIndex api_idx;
const PaHostApiInfo* info = Pa_GetHostApiInfo(Pa_GetDefaultHostApi());
std::cerr << "Default device: " << info->name << std::endl;
for (api_idx = 0; api_idx < Pa_GetHostApiCount(); ++api_idx) {
info = Pa_GetHostApiInfo(api_idx);
std::cerr << "device " << api_idx << ": " << info->name << std::endl;
}
//int frames_per_buffer = get_sample_rate();
int frames_per_buffer = paFramesPerBufferUnspecified;
/*
* We have two separate streams for input and output to work-around a Debian specific
* bug on PortAudio.
*/
/* Open an audio I/O stream. */
err = Pa_OpenDefaultStream( &stream_in,
get_in_channel_count(), /* input channels */
0, /* output */
paFloat32, /* 32 bit floating point output */
get_sample_rate(),
frames_per_buffer, /* frames per buffer, i.e. the number
of sample frames that PortAudio will
request from the callback. Many apps
may want to use
paFramesPerBufferUnspecified, which
tells PortAudio to pick the best,
possibly changing, buffer size.*/
portaudio_in_callback, /* this is your callback function */
static_cast<void*>(this) ); /*This is a pointer that will be passed to
your callback*/
if( err != paNoError ) {
std::cerr << "PortAudio error: " << Pa_GetErrorText( err ) << std::endl;
throw audiosourceexception("Pa_OpenDefaultStream");
}
err = Pa_StartStream( stream_in );
if( err != paNoError ) {
std::cerr << "PortAudio error: " << Pa_GetErrorText( err ) << std::endl;
throw audiosourceexception("Pa_StartStream");
}
/* Open an audio I/O stream. */
err = Pa_OpenDefaultStream( &stream_out,
0, /* input channels */
get_out_channel_count(), /* output */
paFloat32, /* 32 bit floating point output */
get_sample_rate(),
frames_per_buffer, /* frames per buffer, i.e. the number
of sample frames that PortAudio will
request from the callback. Many apps
may want to use
paFramesPerBufferUnspecified, which
tells PortAudio to pick the best,
possibly changing, buffer size.*/
portaudio_out_callback, /* this is your callback function */
static_cast<void*>(this) ); /*This is a pointer that will be passed to
your callback*/
if( err != paNoError ) {
std::cerr << "PortAudio error: " << Pa_GetErrorText( err ) << std::endl;
throw audiosourceexception("Pa_OpenDefaultStream");
}
err = Pa_StartStream( stream_out );
if( err != paNoError ) {
std::cerr << "PortAudio error: " << Pa_GetErrorText( err ) << std::endl;
throw audiosourceexception("Pa_StartStream");
}
}
/*!
Start the audio device
*/
void AudioReaderPortAudio::initialize()
{
initialized = false;
bpmax = sizes.chunk_size / sizes.advance_size;
inputParameters.device=settings->value(s_sdr_deviceindx,s_sdr_deviceindx_def).toInt();
switch (settings->value(s_sdr_bits,s_sdr_bits_def).toInt()) {
case 0:
inputParameters.sampleFormat = paInt16;
break;
case 1:
inputParameters.sampleFormat = paInt24;
break;
case 2:
inputParameters.sampleFormat = paInt32;
break;
}
inputParameters.channelCount=2;
inputParameters.hostApiSpecificStreamInfo=NULL;
if (buff) {
delete [] buff;
}
buff = new unsigned char[sizes.chunk_size];
for (unsigned long i = 0; i < sizes.chunk_size; i++) {
buff[i] = 0;
}
stream = NULL;
err = Pa_Initialize();
if (checkError(err)) {
stop();
return;
}
int numDevices = Pa_GetDeviceCount();
if (numDevices < 0) {
emit(error("ERROR: PortAudio found no audio devices"));
return;
}
if (Pa_GetDeviceInfo(inputParameters.device)==NULL) {
emit(error("ERROR: getdeviceinfo returned null pointer"));
return;
}
if (Pa_GetDeviceInfo(inputParameters.device)->maxInputChannels < 2) {
emit(error("ERROR: audio device does not support stereo"));
return;
}
// set suggested latency
inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency;
periodSize=settings->value(s_sdr_fft,s_sdr_fft_def).toInt()/4;
err = Pa_IsFormatSupported(&inputParameters, NULL,
settings->value(s_sdr_sound_sample_freq,s_sdr_sound_sample_freq_def).toInt());
if (checkError(err)) {
stop();
return;
}
err = Pa_OpenStream(
&stream,
&inputParameters, NULL,
settings->value(s_sdr_sound_sample_freq,s_sdr_sound_sample_freq_def).toInt(),
periodSize,
paClipOff | paDitherOff,
callback,
this);
if (checkError(err)) {
stop();
return;
}
err = Pa_StartStream(stream);
if (checkError(err)) {
stop();
return;
}
mutex.lock();
initialized = true;
running = true;
mutex.unlock();
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData data;
int i;
PaDeviceID inputDevice;
const PaDeviceInfo *pdi;
printf("PortAudio Test: input signal from each channel. %d buffers\n", NUM_BUFFERS );
data.liveChannel = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
#ifdef INPUT_DEVICE_NAME
printf("Try to use device: %s\n", INPUT_DEVICE_NAME );
inputDevice = PaFindDeviceByName(INPUT_DEVICE_NAME);
if( inputDevice == paNoDevice )
{
printf("Could not find %s. Using default instead.\n", INPUT_DEVICE_NAME );
inputDevice = Pa_GetDefaultInputDeviceID();
}
#else
printf("Using default input device.\n");
inputDevice = Pa_GetDefaultInputDeviceID();
#endif
pdi = Pa_GetDeviceInfo( inputDevice );
if( pdi == NULL )
{
printf("Could not get device info!\n");
goto error;
}
data.numChannels = pdi->maxInputChannels;
printf("Input Device name is %s\n", pdi->name );
printf("Input Device has %d channels.\n", pdi->maxInputChannels);
err = Pa_OpenStream(
&stream,
inputDevice,
pdi->maxInputChannels,
paFloat32, /* 32 bit floating point input */
NULL,
OUTPUT_DEVICE,
2,
paFloat32, /* 32 bit floating point output */
NULL,
SAMPLE_RATE,
FRAMES_PER_BUFFER, /* frames per buffer */
NUM_BUFFERS, /* number of buffers, if zero then use default minimum */
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
data.liveChannel = 0;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
for( i=0; i<data.numChannels; i++ )
{
data.liveChannel = i;
printf("Channel %d being sent to output. Hit ENTER for next channel.", i );
fflush(stdout);
getchar();
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
void startStream(PaStream* stream) {
if(!stream) return;
PaError err = Pa_StartStream(stream);
if (err != paNoError)
Logger::logError("PortAudio error:") << Pa_GetErrorText(err) << endl;
}
int main(void)
{
/***************************************************************
Set up the hardware parameters
****************************************************************/
PaStreamParameters inputParameters, outputParameters;
PaStream *stream;
PaError err;
err = Pa_Initialize();
if( err != paNoError ) goto error;
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
if (inputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default input device.\n");
goto error;
}
inputParameters.channelCount = 1; /* Single channel input */
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 1; /* Single channel output */
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
tempOutput =(float*)malloc(FRAMES_PER_BUFFER*sizeof(float));
audioKernelSamples = (int16_t*)malloc(FRAMES_PER_BUFFER*sizeof(int16_t));
/***************************************************************
Initialize the effects from the soundbox!
****************************************************************/
/////////////EQ///////////////
gainL = 12.00f;
gainM = 0.00f;
gainH = 0.00f;
fcL = 300.0f;
fcM = 800.0f;
fcH = 8000.0f;
QL = 0.7f;
QM =2.0f;
QH =0.7f;
/////////////////////////////
/////////////delay///////////
feedback_d = 100;
time_d= 32;
level_d = 127;
/////////////////////////////
///////////Chorus///////////
rate_c= 200;
depth_c = 8;
level_c = 127;
type_c = LFO_SINE;
delayLineSize_c =10000;
////////////////////////////
/////////Flanger///////////
rate_f = 32;
depth_f = 16;
delay_f = 255;
level_f = 255;
type_f = LFO_SINE;
delayLineSize_f = 10000;
//////////////////////////
//////Tremolo////////////
rate_t = 127;
depth_t = 127;
level_t = 255;
type_t = LFO_SINE;
////////////////////////
//////////Vibrato///////
rate_v = 255;
depth_v = 255;
type_v = LFO_SINE;
delayLineSize_v = 10000;
///////////////////
/////// WAH WAH ///////
rate_w = 127;
depth_w = 255;
res_w = 127;
type_w = automatic;
///////////////////////
/////// Phaser ///////
rate_p = 32;
depth_p = 127;
res_p = 255;
///////////////////////
///// Distortion /////
pre_amp_d = 255;
master_d = 160;
tone_d = 180;
//////////////////////
initialize();
/***************************************************************
Open the stream (The communication to the sound card)
****************************************************************/
err = Pa_OpenStream(
&stream,
&inputParameters,
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
0, /* paClipOff, */ /* we won't output out of range samples so don't bother clipping them */
processCallback,
NULL );
/***************************************************************
Error handling code below .......
****************************************************************/
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Hit ENTER to stop program.\n");
getchar();
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
printf("Finished. gNumNoInputs = %d\n", gNumNoInputs );
Pa_Terminate();
return 0;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
}
int main(void)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
TestData data;
int i, j;
printf( "PortAudio Test: output sine wave. SR = %d, BufSize = %d\n",
SAMPLE_RATE, FRAMES_PER_BUFFER );
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = OUTPUT_DEVICE;
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* output will be in-range, so no need to clip */
TestCallback,
&data );
if( err != paNoError ) goto error;
printf("Repeating test %d times.\n", NUM_LOOPS );
for( i=0; i < NUM_LOOPS; ++i )
{
data.phase = 0;
data.generatedFramesCount = 0;
data.callbackReturnedPaComplete = 0;
data.callbackInvokedAfterReturningPaComplete = 0;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for %d seconds.\n", NUM_SECONDS );
/* wait for the callback to complete generating NUM_SECONDS of tone */
do
{
Pa_Sleep( 500 );
}
while( !data.callbackReturnedPaComplete );
printf( "Callback returned paComplete.\n" );
printf( "Waiting for buffers to finish playing...\n" );
/* wait for stream to become inactive,
or for a timeout of approximately NUM_SECONDS
*/
j = 0;
while( Pa_IsStreamActive( stream ) && j < NUM_SECONDS * 2 )
{
printf(".\n" );
Pa_Sleep( 500 );
++j;
}
if( Pa_IsStreamActive( stream ) )
{
printf( "TEST FAILED: Timed out waiting for buffers to finish playing.\n" );
}
else
{
printf("Buffers finished.\n" );
}
if( data.callbackInvokedAfterReturningPaComplete )
{
printf( "TEST FAILED: Callback was invoked after returning paComplete.\n" );
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
}
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
int PlayerObject::setPlaying(bool playing) {
PlayerObject* player = this;
bool oldplayingstate = false;
PyScopedGIL gil;
{
PyScopedGIUnlock gunlock;
player->workerThread.start(); // if not running yet, start
if(!player->outStream.get())
player->outStream.reset(new OutStream(this));
assert(player->outStream.get() != NULL);
if(playing && !player->outStream->stream) {
PaError ret;
ret = Pa_OpenDefaultStream(
&player->outStream->stream,
0,
player->outNumChannels, // numOutputChannels
paInt16, // sampleFormat
player->outSamplerate, // sampleRate
AUDIO_BUFFER_SIZE / 2, // framesPerBuffer,
&paStreamCallback,
player //void *userData
);
if(ret != paNoError) {
PyErr_SetString(PyExc_RuntimeError, "Pa_OpenDefaultStream failed");
if(player->outStream->stream)
player->outStream->close();
playing = 0;
}
}
if(playing) {
player->needRealtimeReset = 1;
Pa_StartStream(player->outStream->stream);
} else
player->outStream->stop();
oldplayingstate = player->playing;
player->playing = playing;
}
if(!PyErr_Occurred() && player->dict) {
Py_INCREF(player->dict);
PyObject* onPlayingStateChange = PyDict_GetItemString(player->dict, "onPlayingStateChange");
if(onPlayingStateChange && onPlayingStateChange != Py_None) {
Py_INCREF(onPlayingStateChange);
PyObject* kwargs = PyDict_New();
assert(kwargs);
PyDict_SetItemString_retain(kwargs, "oldState", PyBool_FromLong(oldplayingstate));
PyDict_SetItemString_retain(kwargs, "newState", PyBool_FromLong(playing));
PyObject* retObj = PyEval_CallObjectWithKeywords(onPlayingStateChange, NULL, kwargs);
Py_XDECREF(retObj);
// errors are not fatal from the callback, so handle it now and go on
if(PyErr_Occurred())
PyErr_Print();
Py_DECREF(kwargs);
Py_DECREF(onPlayingStateChange);
}
Py_DECREF(player->dict);
}
return PyErr_Occurred() ? -1 : 0;
}
int main(void)
{
PaStream *stream;
PaStreamParameters outputParameters;
PaError err;
paTestData data;
int i;
printf("Play different tone sine waves that alternate between left and right channel.\n");
printf("The low tone should be on the left channel.\n");
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
data.left_phase = data.right_phase = 0;
data.currentBalance = 0.0;
data.targetBalance = 0.0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream( &stream,
NULL, /* No input. */
&outputParameters, /* As above. */
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for several seconds.\n");
for( i=0; i<4; i++ )
{
printf("Hear low sound on left side.\n");
data.targetBalance = 0.01;
Pa_Sleep( 1000 );
printf("Hear high sound on right side.\n");
data.targetBalance = 0.99;
Pa_Sleep( 1000 );
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
PaError pa_open_callback(double sampleRate, int inchannels, int outchannels,
int framesperbuf, int nbuffers, int indeviceno, int outdeviceno, PaStreamCallback *callbackfn)
{
long bytesPerSample;
PaError err;
PaStreamParameters instreamparams, outstreamparams;
PaStreamParameters*p_instreamparams=0, *p_outstreamparams=0;
/* fprintf(stderr, "nchan %d, flags %d, bufs %d, framesperbuf %d\n",
nchannels, flags, nbuffers, framesperbuf); */
instreamparams.device = indeviceno;
instreamparams.channelCount = inchannels;
instreamparams.sampleFormat = paFloat32;
instreamparams.suggestedLatency = 0; /* was nbuffers*framesperbuf/sampleRate */
instreamparams.hostApiSpecificStreamInfo = 0;
outstreamparams.device = outdeviceno;
outstreamparams.channelCount = outchannels;
outstreamparams.sampleFormat = paFloat32;
outstreamparams.suggestedLatency = 0;
outstreamparams.hostApiSpecificStreamInfo = 0;
if(inchannels>0 && indeviceno >= 0)
p_instreamparams=&instreamparams;
if(outchannels>0 && outdeviceno >= 0)
p_outstreamparams=&outstreamparams;
err=Pa_IsFormatSupported(p_instreamparams, p_outstreamparams, sampleRate);
if (paFormatIsSupported != err)
{
/* check whether we have to change the numbers of channel and/or samplerate */
const PaDeviceInfo* info = 0;
double inRate=0, outRate=0;
if (inchannels>0)
{
if (NULL != (info = Pa_GetDeviceInfo( instreamparams.device )))
{
inRate=info->defaultSampleRate;
if(info->maxInputChannels<inchannels)
instreamparams.channelCount=info->maxInputChannels;
}
}
if (outchannels>0)
{
if (NULL != (info = Pa_GetDeviceInfo( outstreamparams.device )))
{
outRate=info->defaultSampleRate;
if(info->maxOutputChannels<outchannels)
outstreamparams.channelCount=info->maxOutputChannels;
}
}
if (err == paInvalidSampleRate)
{
sampleRate=outRate;
}
err=Pa_IsFormatSupported(p_instreamparams, p_outstreamparams,
sampleRate);
if (paFormatIsSupported != err)
goto error;
}
err = Pa_OpenStream(
&pa_stream,
p_instreamparams,
p_outstreamparams,
sampleRate,
framesperbuf,
paNoFlag, /* portaudio will clip for us */
callbackfn,
0);
if (err != paNoError)
goto error;
err = Pa_StartStream(pa_stream);
if (err != paNoError)
{
fprintf(stderr, "Pa_StartStream failed; closing audio stream...\n");
pa_close_audio();
goto error;
}
sys_dacsr=sampleRate;
return paNoError;
error:
pa_stream = NULL;
return err;
}
int main(void)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
int safeSineCount, stressedSineCount;
int safeUnderflowCount, stressedUnderflowCount;
paTestData data = {0};
double load;
printf("PortAudio Test: output sine waves, count underflows. SR = %d, BufSize = %d. MAX_LOAD = %f\n",
SAMPLE_RATE, FRAMES_PER_BUFFER, (float)MAX_LOAD );
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 1; /* mono output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Establishing load conditions...\n" );
/* Determine number of sines required to get to 50% */
do
{
Pa_Sleep( 100 );
load = Pa_GetStreamCpuLoad( stream );
printf("sineCount = %d, CPU load = %f\n", data.sineCount, load );
if( load < 0.3 )
{
data.sineCount += 10;
}
else if( load < 0.4 )
{
data.sineCount += 2;
}
else
{
data.sineCount += 1;
}
}
while( load < 0.5 && data.sineCount < (MAX_SINES-1));
safeSineCount = data.sineCount;
/* Calculate target stress value then ramp up to that level*/
stressedSineCount = (int) (2.0 * data.sineCount * MAX_LOAD );
if( stressedSineCount > MAX_SINES )
stressedSineCount = MAX_SINES;
for( ; data.sineCount < stressedSineCount; data.sineCount+=4 )
{
Pa_Sleep( 100 );
load = Pa_GetStreamCpuLoad( stream );
printf("STRESSING: sineCount = %d, CPU load = %f\n", data.sineCount, load );
}
printf("Counting underflows for 5 seconds.\n");
data.countUnderflows = 1;
Pa_Sleep( 5000 );
stressedUnderflowCount = data.outputUnderflowCount;
data.countUnderflows = 0;
data.sineCount = safeSineCount;
printf("Resuming safe load...\n");
Pa_Sleep( 1500 );
data.outputUnderflowCount = 0;
Pa_Sleep( 1500 );
load = Pa_GetStreamCpuLoad( stream );
printf("sineCount = %d, CPU load = %f\n", data.sineCount, load );
printf("Counting underflows for 5 seconds.\n");
data.countUnderflows = 1;
Pa_Sleep( 5000 );
safeUnderflowCount = data.outputUnderflowCount;
printf("Stop stream.\n");
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
if( stressedUnderflowCount == 0 )
printf("Test failed, no output underflows detected under stress.\n");
else if( safeUnderflowCount != 0 )
printf("Test failed, %d unexpected underflows detected under safe load.\n", safeUnderflowCount);
else
printf("Test passed, %d expected output underflows detected under stress, 0 unexpected underflows detected under safe load.\n", stressedUnderflowCount );
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
int main(void)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
paTestData data;
int i;
printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d\n",
SAMPLE_RATE, FRAMES_PER_BUFFER);
data.phase = 0;
for (i = 0 ; i < 12 ; i++) {
data.amplitudes[i] = 0;
data.states[i] = DECAY;
}
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 1; /* mono output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
sprintf( data.message, "No Message" );
err = Pa_SetStreamFinishedCallback( stream, &StreamFinished );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
/* set up unbuffered reading */
struct termios tio;
tcgetattr(1,&tio);
tio.c_lflag &=(~ICANON & ~ECHO);
tcsetattr(1,TCSANOW,&tio);
int pressed = -1;
while(1) {
switch (getc(stdin)) {
case 'C':
pressed = 0;
break;
case 'd':
pressed = 1;
break;
case 'D':
pressed = 2;
break;
case 'e':
pressed = 3;
break;
case 'E':
pressed = 4;
break;
case 'F':
pressed = 5;
break;
case 'g':
pressed = 6;
break;
case 'G':
pressed = 7;
break;
case 'a':
pressed = 8;
break;
case 'A':
pressed = 9;
break;
case 'b':
pressed = 10;
break;
case 'B':
pressed = 11;
break;
}
if (pressed != -1) {
data.states[pressed] = ATTACK;
}
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
int main(void)
{
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
paTestData data;
int i;
printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER);
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
data.left_phase = data.right_phase = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
sprintf( data.message, "No Message" );
err = Pa_SetStreamFinishedCallback( stream, &StreamFinished );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for %d seconds.\n", NUM_SECONDS );
Pa_Sleep( NUM_SECONDS * 1000 );
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
static PaCtx *
pa_phone_setup(void) {
PaCtx *ctx;
int err, i, srcerr;
PaError err2;
err = paNoError;
err2 = 0;
if ((ctx = calloc(1, sizeof(PaCtx))) == NULL) {
WHY("Unable to allocate PA context");
err2 = 1;
goto error;
}
/* Init mutex */
if (pthread_mutex_init(&ctx->mtx, NULL) != 0) {
WHYF("Unable to init mutex: %s\n", strerror(errno));
err2 = 1;
goto error;
}
/* Allocate FIFOs */
i = IN_FRAMES * 10 * sizeof(int16_t);
printf("Allocating %d byte FIFOs\n", i);
if ((ctx->incoming = fifo_alloc(i)) == NULL) {
WHY("Unable to allocate incoming FIFO\n");
err2 = 1;
goto error;
}
if ((ctx->incrate = fifo_alloc(i)) == NULL) {
WHY("Unable to allocate incoming SRC FIFO\n");
err2 = 1;
goto error;
}
if ((ctx->outgoing = fifo_alloc(i)) == NULL) {
WHY("Unable to allocate outgoing FIFO\n");
err2 = 1;
goto error;
}
/* Init sample rate converter */
if ((ctx->src = src_new(SRC_SINC_BEST_QUALITY, 1, &srcerr)) == NULL) {
WHYF("Unable to init sample rate converter: %d\n", srcerr);
err2 = 1;
goto error;
}
/* Init echo canceller */
if ((ctx->echocan = echo_can_init(ECHO_LEN, ADAPT_MODE)) == NULL) {
WHY("Unable to init echo canceller\n");
err2 = 1;
goto error;
}
/* Init codec2 */
if ((ctx->codec2 = codec2_create()) == NULL) {
WHY("Unable to init codec2\n");
err2 = 1;
goto error;
}
/* Initialize Port Audio library */
if ((err = Pa_Initialize()) != paNoError)
goto error;
/* Open an audio I/O stream. */
if ((err = Pa_OpenDefaultStream(&ctx->stream,
1, /* input channels */
1, /* output channels */
paInt16,
SAMPLE_RATE,
IN_FRAMES, /* frames per buffer */
patestCallback,
&ctx)) != paNoError)
goto error;
/* Start stream */
if ((err = Pa_StartStream(ctx->stream)) != paNoError)
goto error;
/* Close down stream, PA, etc */
/* XXX: hangs in pthread_join on Ubuntu 10.04 */
#ifndef linux
if ((err = Pa_StopStream(ctx->stream)) != paNoError)
goto error;
#endif
/* Do stuff */
if ((err = Pa_CloseStream(ctx->stream)) != paNoError)
goto error;
error:
Pa_Terminate();
/* Free things */
freectx(ctx);
if (err != paNoError)
WHYF("Port audio error: %s\n", Pa_GetErrorText(err));
return NULL;
}
int main(void)
{
PaStreamParameters inputParameters, outputParameters;
PaStream *stream;
PaError err;
SAMPLE *recordedSamples;
int i;
int totalFrames;
int numSamples;
int numBytes;
SAMPLE max, average, val;
printf("patest_read_record.c\n");
fflush(stdout);
totalFrames = NUM_SECONDS * SAMPLE_RATE; /* Record for a few seconds. */
numSamples = totalFrames * NUM_CHANNELS;
numBytes = numSamples * sizeof(SAMPLE);
recordedSamples = (SAMPLE *) malloc( numBytes );
if( recordedSamples == NULL )
{
printf("Could not allocate record array.\n");
exit(1);
}
for( i=0; i<numSamples; i++ ) recordedSamples[i] = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
inputParameters.channelCount = NUM_CHANNELS;
inputParameters.sampleFormat = PA_SAMPLE_TYPE;
inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputParameters.device )->defaultLowInputLatency;
inputParameters.hostApiSpecificStreamInfo = NULL;
/* Record some audio. -------------------------------------------- */
err = Pa_OpenStream(
&stream,
&inputParameters,
NULL, /* &outputParameters, */
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
NULL, /* no callback, use blocking API */
NULL ); /* no callback, so no callback userData */
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Now recording!!\n");
fflush(stdout);
err = Pa_ReadStream( stream, recordedSamples, totalFrames );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
/* Measure maximum peak amplitude. */
max = 0;
average = 0;
for( i=0; i<numSamples; i++ )
{
val = recordedSamples[i];
if( val < 0 ) val = -val; /* ABS */
if( val > max )
{
max = val;
}
average += val;
}
average = average / numSamples;
printf("Sample max amplitude = "PRINTF_S_FORMAT"\n", max );
printf("Sample average = "PRINTF_S_FORMAT"\n", average );
/* Was as below. Better choose at compile time because this
keeps generating compiler-warnings:
if( PA_SAMPLE_TYPE == paFloat32 )
{
printf("sample max amplitude = %f\n", max );
printf("sample average = %f\n", average );
}
else
{
printf("sample max amplitude = %d\n", max );
printf("sample average = %d\n", average );
}
*/
/* Write recorded data to a file. */
#if 0
{
FILE *fid;
fid = fopen("recorded.raw", "wb");
if( fid == NULL )
{
printf("Could not open file.");
}
else
{
fwrite( recordedSamples, NUM_CHANNELS * sizeof(SAMPLE), totalFrames, fid );
fclose( fid );
printf("Wrote data to 'recorded.raw'\n");
}
}
#endif
/* Playback recorded data. -------------------------------------------- */
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
outputParameters.channelCount = NUM_CHANNELS;
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
printf("Begin playback.\n");
fflush(stdout);
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
NULL, /* no callback, use blocking API */
NULL ); /* no callback, so no callback userData */
if( err != paNoError ) goto error;
if( stream )
{
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Waiting for playback to finish.\n");
fflush(stdout);
err = Pa_WriteStream( stream, recordedSamples, totalFrames );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
printf("Done.\n");
fflush(stdout);
}
free( recordedSamples );
Pa_Terminate();
return 0;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return -1;
}
int main(void) {
PaStreamParameters outputParameters;
PaStream* stream;
PaError err = paNoError;
paTestData data;
int totalFrames;
int numSamples;
int numBytes;
data.maxFrameIndex = totalFrames = NUM_SECONDS * SAMPLE_RATE; /* Record for a few seconds. */
data.frameIndex = 0;
numSamples = totalFrames * NUM_CHANNELS;
numBytes = numSamples * sizeof(SAMPLE);
data.recordedSamples = (SAMPLE *) malloc( numBytes ); /* From now on, recordedSamples is initialised. */
if( data.recordedSamples == NULL ) {
printf("Could not allocate record array.\n");
goto done;
}
if( err != paNoError ) goto done;
FILE * pFile;
long lSize;
size_t result;
pFile = fopen ( "recorded.raw" , "rb" );
if (pFile==NULL) {
fputs ("Error opening file!",stderr);
exit (1);
}
// obtain file size:
fseek (pFile , 0 , SEEK_END);
lSize = ftell (pFile);
rewind (pFile);
// copy the file into the buffer:
result = fread( data.recordedSamples, NUM_CHANNELS * sizeof(SAMPLE), lSize / (NUM_CHANNELS * sizeof(SAMPLE)), pFile );
if (result != lSize / (NUM_CHANNELS * sizeof(SAMPLE))) {
fputs ("Reading error, file may be corrupted\n",stderr);
exit (3);
}
fclose (pFile);
/* Playback recorded data. -------------------------------------------- */
data.frameIndex = 0;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto done;
}
outputParameters.channelCount = 2; /* stereo output */
outputParameters.sampleFormat = PA_SAMPLE_TYPE;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
printf("\n=== Now playing back. ===\n");
fflush(stdout);
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
playCallback,
&data );
if( err != paNoError ) goto done;
if( stream )
{
err = Pa_StartStream( stream );
if( err != paNoError ) goto done;
printf("Waiting for playback to finish.\n");
fflush(stdout);
while( ( err = Pa_IsStreamActive( stream ) ) == 1 ) Pa_Sleep(100);
if( err < 0 ) goto done;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto done;
printf("Done.\n");
fflush(stdout);
}
done:
Pa_Terminate();
if( data.recordedSamples ) /* Sure it is NULL or valid. */
free( data.recordedSamples );
if( err != paNoError ) {
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
err = 1; /* Always return 0 or 1, but no other return codes. */
}
return err;
}
int main(void)
{
PortAudioStream *stream;
PaError err;
paTestData data;
int i;
int timeout;
printf("Play different tone sine waves that alternate between left and right channel.\n");
printf("The low tone should be on the left channel.\n");
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
data.left_phase = data.right_phase = data.toggle = 0;
data.countDown = SAMPLE_RATE;
err = Pa_Initialize();
if( err != paNoError ) goto error;
err = Pa_OpenStream(
&stream,
paNoDevice,/* default input device */
0, /* no input */
paFloat32, /* 32 bit floating point input */
NULL,
Pa_GetDefaultOutputDeviceID(), /* default output device */
2, /* stereo output */
paFloat32, /* 32 bit floating point output */
NULL,
SAMPLE_RATE,
FRAMES_PER_BUFFER, /* frames per buffer */
0, /* number of buffers, if zero then use default minimum */
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for several seconds.\n");
timeout = NUM_SECONDS * 4;
while( timeout > 0 )
{
Pa_Sleep( 300 );
timeout -= 1;
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
int main(void)
{
int i;
PaStream* stream;
PaStreamParameters outputParameters;
PaError err;
paTestData data = {0};
double load;
printf("PortAudio Test: output sine wave. SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER);
/* initialise sinusoidal wavetable */
for( i=0; i<TABLE_SIZE; i++ )
{
data.sine[i] = (float) sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. );
}
data.sine[TABLE_SIZE] = data.sine[0]; /* set guard point */
err = Pa_Initialize();
if( err != paNoError )
goto error;
outputParameters.device = Pa_GetDefaultOutputDevice(); /* Default output device. */
if (outputParameters.device == paNoDevice) {
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2; /* Stereo output. */
outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output. */
outputParameters.hostApiSpecificStreamInfo = NULL;
outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputParameters.device)
->defaultHighOutputLatency;
err = Pa_OpenStream(&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff, /* No out of range samples should occur. */
patestCallback,
&data);
if( err != paNoError )
goto error;
err = Pa_StartStream( stream );
if( err != paNoError )
goto error;
/* Play an increasing number of sine waves until we hit MAX_USAGE */
do {
data.numSines++;
Pa_Sleep(200);
load = Pa_GetStreamCpuLoad(stream);
printf("numSines = %d, CPU load = %f\n", data.numSines, load );
fflush(stdout);
} while((load < MAX_USAGE) && (data.numSines < MAX_SINES));
Pa_Sleep(2000); /* Stay for 2 seconds around 80% CPU. */
err = Pa_StopStream( stream );
if( err != paNoError )
goto error;
err = Pa_CloseStream( stream );
if( err != paNoError )
goto error;
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
static void *output_thread(void *ptr) {
int err;
int output_buffer_size;
#ifndef PORTAUDIO_DEV
int num_mixers, nbVolumes, volumeIdx;
#endif
struct timeval now;
struct timespec timeout;
slimaudio_t *audio = (slimaudio_t *) ptr;
audio->output_STMs = false;
audio->output_STMu = false;
err = Pa_Initialize();
if (err != paNoError) {
printf("PortAudio error4: %s Could not open any audio devices.\n", Pa_GetErrorText(err) );
exit(-1);
}
if ( audio->renice )
if ( slimproto_renice_thread (-5) ) /* Increase priority */
fprintf(stderr, "output_thread: renice failed. Got Root?\n");
#ifndef PORTAUDIO_DEV
DEBUGF("output_thread: output_device_id : %i\n", audio->output_device_id );
DEBUGF("output_thread: pa_framesPerBuffer: %lu\n", pa_framesPerBuffer );
DEBUGF("output_thread: pa_numberOfBuffers: %lu\n", pa_numberOfBuffers );
err = Pa_OpenStream( &audio->pa_stream, /* stream */
paNoDevice, /* input device */
0, /* input channels */
0, /* input sample format */
NULL, /* input driver info */
audio->output_device_id,/* output device */
2, /* output channels */
paInt16, /* output sample format */
NULL, /* output driver info */
44100.0, /* sample rate */
pa_framesPerBuffer, /* frames per buffer */
pa_numberOfBuffers, /* number of buffers */
paNoFlag, /* stream flags */
pa_callback, /* callback */
audio); /* user data */
#else
PaStreamParameters outputParameters;
const PaDeviceInfo * paDeviceInfo;
float newLatency;
#ifdef PADEV_WASAPI
PaWasapiStreamInfo streamInfo;
const PaHostApiInfo *paHostApiInfo;
#endif
paDeviceInfo = Pa_GetDeviceInfo(audio->output_device_id);
/* Device is not stereo or better, abort */
if (paDeviceInfo->maxOutputChannels < 2)
{
printf("output_thread: PortAudio device does not support 44.1KHz, 16-bit, stereo audio.\n");
printf("output_thread: Use -L for a list of supported audio devices, then use -o followed\n");
printf("output_thread: by the device number listed before the colon. See -h for details.\n");
exit(-2);
}
outputParameters.device = audio->output_device_id;
#ifdef SLIMPROTO_ZONES
outputParameters.channelCount = 2 * audio->output_num_zones;
#else
outputParameters.channelCount = 2;
#endif
outputParameters.sampleFormat = paInt16;
outputParameters.suggestedLatency = paDeviceInfo->defaultHighOutputLatency;
if ( audio->modify_latency )
{
newLatency = (float) audio->user_latency / 1000.0;
if ( ( newLatency > 1.0 ) || ( newLatency <= paDeviceInfo->defaultLowOutputLatency ) )
{
fprintf (stderr, "User defined latency %f out of range %f-1.0, using default.\n",
newLatency, paDeviceInfo->defaultLowOutputLatency );
newLatency = paDeviceInfo->defaultHighOutputLatency;
}
outputParameters.suggestedLatency = newLatency ;
}
#ifdef PADEV_WASAPI
/* Use exclusive mode for WASAPI device, default is shared */
paHostApiInfo = Pa_GetHostApiInfo ( paDeviceInfo->hostApi );
if ( paHostApiInfo != NULL )
{
if ( paHostApiInfo->type == paWASAPI )
{
/* Use exclusive mode for WasApi device, default is shared */
if (wasapi_exclusive)
{
streamInfo.size = sizeof(PaWasapiStreamInfo);
streamInfo.hostApiType = paWASAPI;
streamInfo.version = 1;
streamInfo.flags = paWinWasapiExclusive;
outputParameters.hostApiSpecificStreamInfo = &streamInfo;
DEBUGF("WASAPI: Exclusive\n");
}
else
{
outputParameters.hostApiSpecificStreamInfo = NULL;
DEBUGF("WASAPI: Shared\n");
}
}
}
#else
outputParameters.hostApiSpecificStreamInfo = NULL;
#endif
DEBUGF("paDeviceInfo->deviceid %d\n", outputParameters.device);
DEBUGF("paDeviceInfo->maxOutputChannels %i\n", paDeviceInfo->maxOutputChannels);
DEBUGF("outputParameters.suggestedLatency %f\n", outputParameters.suggestedLatency);
DEBUGF("paDeviceInfo->defaultHighOutputLatency %f\n", (float) paDeviceInfo->defaultHighOutputLatency);
DEBUGF("paDeviceInfo->defaultLowOutputLatency %f\n", (float) paDeviceInfo->defaultLowOutputLatency);
DEBUGF("paDeviceInfo->defaultSampleRate %f\n", paDeviceInfo->defaultSampleRate);
err = Pa_OpenStream ( &audio->pa_stream, /* stream */
NULL, /* inputParameters */
&outputParameters, /* outputParameters */
44100.0, /* sample rate */
paFramesPerBufferUnspecified, /* framesPerBuffer */
paPrimeOutputBuffersUsingStreamCallback, /* streamFlags */
pa_callback, /* streamCallback */
audio); /* userData */
#endif
#ifdef BSD_THREAD_LOCKING
pthread_mutex_lock(&audio->output_mutex);
#endif
if (err != paNoError) {
printf("output_thread: PortAudio error1: %s\n", Pa_GetErrorText(err) );
exit(-1);
}
#ifndef PORTAUDIO_DEV
num_mixers = Px_GetNumMixers(audio->pa_stream);
while (--num_mixers >= 0) {
DEBUGF("Mixer: %s\n", Px_GetMixerName(audio->pa_stream, num_mixers));
}
if (audio->volume_control == VOLUME_DRIVER) {
DEBUGF("Opening mixer.\n" );
audio->px_mixer = Px_OpenMixer(audio->pa_stream, 0);
}
if (audio->px_mixer != NULL) {
DEBUGF("Px_mixer = %p\n", audio->px_mixer);
DEBUGF("PCM volume supported: %d.\n",
Px_SupportsPCMOutputVolume(audio->px_mixer));
nbVolumes = Px_GetNumOutputVolumes(audio->px_mixer);
DEBUGF("Nb volumes supported: %d.\n", nbVolumes);
for (volumeIdx=0; volumeIdx<nbVolumes; ++volumeIdx) {
DEBUGF("Volume %d: %s\n", volumeIdx,
Px_GetOutputVolumeName(audio->px_mixer, volumeIdx));
}
}
#endif
while (audio->output_state != QUIT) {
switch (audio->output_state) {
case STOPPED:
audio->decode_num_tracks_started = 0L;
audio->stream_samples = 0UL;
audio->pa_streamtime_offset = audio->stream_samples;
DEBUGF("output_thread STOPPED: %llu\n",audio->pa_streamtime_offset);
slimaudio_buffer_set_readopt(audio->output_buffer, BUFFER_BLOCKING);
case PAUSED:
/* We report ourselves to the server every few seconds
** as a keep-alive. This is required for Squeezebox Server
** v6.5.x although technically, "stat" is not a valid event
** code for the STAT Client->Server message. This was
** lifted by observing how a Squeezebox3 reports itself to
** the server using Squeezebox Server's d_slimproto and
** d_slimproto_v tracing services. Note that Squeezebox3
** seems to report every 1 second or so, but the server only
** drops the connection after 15-20 seconds of inactivity.
*/
DEBUGF("output_thread PAUSED: %llu\n",audio->pa_streamtime_offset);
if (audio->keepalive_interval <= 0) {
pthread_cond_wait(&audio->output_cond, &audio->output_mutex);
}
else {
gettimeofday(&now, NULL);
timeout.tv_sec = now.tv_sec + audio->keepalive_interval;
timeout.tv_nsec = now.tv_usec * 1000;
err = pthread_cond_timedwait(&audio->output_cond,
&audio->output_mutex, &timeout);
if (err == ETIMEDOUT) {
DEBUGF("Sending keepalive. Interval=%ds.\n", audio->keepalive_interval);
output_thread_stat(audio, "stat");
}
}
break;
case PLAY:
audio->output_predelay_frames = audio->output_predelay_msec * 44.100;
DEBUGF("output_thread PLAY: output_predelay_frames: %i\n",
audio->output_predelay_frames);
output_buffer_size = slimaudio_buffer_available(audio->output_buffer);
DEBUGF("output_thread BUFFERING: output_buffer_size: %i output_threshold: %i",
output_buffer_size, audio->output_threshold);
DEBUGF(" buffering_timeout: %i\n", audio->buffering_timeout);
if ( (output_buffer_size < audio->output_threshold) && (audio->buffering_timeout > 0) )
{
pthread_mutex_unlock(&audio->output_mutex);
pthread_cond_broadcast(&audio->output_cond);
Pa_Sleep(100);
pthread_mutex_lock(&audio->output_mutex);
audio->buffering_timeout--;
}
else
{
DEBUGF("output_thread PLAY: start stream: %llu\n",
audio->pa_streamtime_offset);
audio->buffering_timeout = BUFFERING_TIMEOUT;
err = Pa_StartStream(audio->pa_stream);
if (err != paNoError)
{
printf("output_thread: PortAudio error2: %s\n", Pa_GetErrorText(err));
exit(-1);
}
audio->output_state = PLAYING;
pthread_cond_broadcast(&audio->output_cond);
}
break;
case BUFFERING:
DEBUGF("output_thread BUFFERING: %llu\n",audio->pa_streamtime_offset);
case PLAYING:
gettimeofday(&now, NULL);
timeout.tv_sec = now.tv_sec + 1;
timeout.tv_nsec = now.tv_usec * 1000;
err = pthread_cond_timedwait(&audio->output_cond, &audio->output_mutex, &timeout);
if (err == ETIMEDOUT)
{
DEBUGF("output_thread ETIMEDOUT-PLAYING: %llu\n",audio->pa_streamtime_offset);
output_thread_stat(audio, "STMt");
}
/* Track started */
if (audio->output_STMs)
{
audio->output_STMs = false;
audio->decode_num_tracks_started++;
audio->replay_gain = audio->start_replay_gain;
slimaudio_output_vol_adjust(audio);
audio->pa_streamtime_offset = audio->stream_samples;
DEBUGF("output_thread STMs-PLAYING: %llu\n",audio->pa_streamtime_offset);
output_thread_stat(audio, "STMs");
}
/* Data underrun
** On buffer underrun causes the server to switch to the next track.
*/
if (audio->output_STMu)
{
audio->output_STMu = false;
audio->output_state = STOP;
DEBUGF("output_thread STMu-PLAYING: %llu\n",audio->pa_streamtime_offset);
output_thread_stat(audio, "STMu");
pthread_cond_broadcast(&audio->output_cond);
}
break;
case STOP:
#ifndef PORTAUDIO_DEV
if ( (err = Pa_StreamActive(audio->pa_stream) ) > 0)
{
err = Pa_StopStream(audio->pa_stream);
if (err != paNoError)
{
printf("output_thread: PortAudio error3: %s\n", Pa_GetErrorText(err) );
exit(-1);
}
}
else
{
if ( err != paNoError)
{
printf("output_thread: PortAudio error9: %s\n",
Pa_GetErrorText(err) );
exit(-1);
}
}
#else
if ( (err = Pa_IsStreamActive(audio->pa_stream)) > 0) {
err = Pa_StopStream(audio->pa_stream);
if (err != paNoError) {
printf("output_thread[STOP]: PortAudio error3: %s\n",
Pa_GetErrorText(err) );
exit(-1);
}
} else if ( err != paNoError) {
printf("output_thread[STOP ISACTIVE]: PortAudio error3: %s\n",
Pa_GetErrorText(err) );
exit(-1);
}
#endif
audio->output_state = STOPPED;
DEBUGF("output_thread STOP: %llu\n",audio->pa_streamtime_offset);
pthread_cond_broadcast(&audio->output_cond);
break;
case PAUSE:
#ifndef PORTAUDIO_DEV
if ( (err = Pa_StreamActive(audio->pa_stream) ) > 0)
{
err = Pa_StopStream(audio->pa_stream);
if (err != paNoError)
{
printf("output_thread: PortAudio error10: %s\n", Pa_GetErrorText(err));
exit(-1);
}
}
else
{
if ( err != paNoError)
{
printf("output_thread: PortAudio error11: %s\n",
Pa_GetErrorText(err) );
exit(-1);
}
}
#else
if ( (err = Pa_IsStreamActive(audio->pa_stream)) > 0) {
err = Pa_StopStream(audio->pa_stream);
if (err != paNoError) {
printf("output_thread[PAUSE]: PortAudio error3: %s\n",
Pa_GetErrorText(err) );
exit(-1);
}
} else if ( err != paNoError) {
printf("output_thread[PAUSE ISACTIVE]: PortAudio error3: %s\n",
Pa_GetErrorText(err) );
exit(-1);
}
#endif
audio->output_state = PAUSED;
DEBUGF("output_thread PAUSE: %llu\n",audio->pa_streamtime_offset);
pthread_cond_broadcast(&audio->output_cond);
break;
case QUIT:
DEBUGF("output_thread QUIT: %llu\n",audio->pa_streamtime_offset);
break;
}
}
pthread_mutex_unlock(&audio->output_mutex);
#ifndef PORTAUDIO_DEV
if (audio->px_mixer != NULL) {
Px_CloseMixer(audio->px_mixer);
audio->px_mixer = NULL;
}
#endif
err = Pa_CloseStream(audio->pa_stream);
if (err != paNoError) {
printf("output_thread[exit]: PortAudio error3: %s\n", Pa_GetErrorText(err) );
exit(-1);
}
audio->pa_stream = NULL;
Pa_Terminate();
DEBUGF("output_thread: PortAudio terminated\n");
return 0;
}
Main()
{
mScale = 0.1f;
mOffset = 1.0f;
mDataOffset = 0;
isClicked = false;
screen = Vec2<unsigned int>(800, 600);
std::setlocale(LC_ALL, "en_US.UTF-8");
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
//glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
GLFWwindow* window = glfwCreateWindow(screen.x, screen.y, "test", nullptr, nullptr);
if (window == nullptr)
{
printf("cant create window");
return;
}
glfwSetWindowSizeCallback(window, windowSizeCallback);
glfwSetKeyCallback(window, keyCallback);
glfwSetMouseButtonCallback(window, clickCallback);
glfwSetCursorPosCallback(window, mouseCallback);
glfwMakeContextCurrent(window);
glewExperimental = true;
glewInit();
int tmp;
glGetIntegerv(GL_MAX_ELEMENTS_VERTICES , &tmp);
std::cout << "GL_MAX_ELEMENTS_VERTICES: " << tmp << std::endl;
int err = Pa_Initialize();
if (err != paNoError)
printf("error");
int num = Pa_GetDeviceCount();
const PaDeviceInfo* devInfo;
const PaHostApiInfo* apiInfo;
for (int i = 0; i < num; ++i) {
devInfo = Pa_GetDeviceInfo(i);
apiInfo = Pa_GetHostApiInfo(devInfo->hostApi);
printf("%i, %s on %s\n", i, devInfo->name, apiInfo->name);
}
float sampleRate = 44100.0f;
double t = glfwGetTime();
Kern k(sampleRate, 12, 4 * 16.352f, sampleRate / 2);
BlockMatrix<std::complex<double>> b(k.K, k.mN0, k.mB, 0.01);
mAudioData = new double[b.getWidth()];
mAudioLength = b.getWidth();
for (unsigned int i = 0; i < mAudioLength; ++i) {
mAudioData[i] = wave(55, sampleRate, i) + wave(110, sampleRate, i) + wave(220, sampleRate, i)
+ wave(440, sampleRate, i) + wave(880, sampleRate, i) + wave(1760, sampleRate, i)
+ wave(3520, sampleRate, i) + wave(7040, sampleRate, i);
}
printf("kernel time:%f\n", glfwGetTime() - t);
float drawArray[k.mB * 2];
std::complex<double> out[k.mB];
CQT::transform(mAudioData, out, b, mAudioLength);
t = glfwGetTime();
printf("transform time:%f\n", glfwGetTime() - t);
//glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(debugCallback, nullptr);
//glEnable(GL_DEBUG_OUTPUT);
printf("%s\n", glGetString(GL_VERSION));
Shader fs("res/shader/fragment.c", true, GL_FRAGMENT_SHADER);
Shader vs("res/shader/vertex.c", true, GL_VERTEX_SHADER);
Program* p = new Program();
p->attach(fs);
p->attach(vs);
p->build();
p->use();
Program p2;
Shader fs2("res/shader/fragment2.c", true, GL_FRAGMENT_SHADER);
Shader vs2("res/shader/vertex2.c", true, GL_VERTEX_SHADER);
p2.attach(fs2);
p2.attach(vs2);
p2.build();
p2.use();
int uniformData = p2.getUniformLocation("data");
unsigned int waterfallSize = 512;
tm = new TextureManager();
unsigned int waterfallTexture;
unsigned int waterfallId = tm->getFreeTexture();
glGenTextures(1, &waterfallTexture);
glActiveTexture(GL_TEXTURE0 + waterfallId);
glBindTexture( GL_TEXTURE0, waterfallTexture );
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
unsigned char* textureTmp = new unsigned char[waterfallSize * b.getWidth()];
glTexImage2D( GL_TEXTURE_2D_ARRAY, 0, GL_R8, b.getWidth(), waterfallSize, 0, GL_RED, GL_UNSIGNED_BYTE, textureTmp);
delete textureTmp;
float max = 0;
for (unsigned int i = 0; i < k.mB; ++i) {
drawArray[2 * i + 0] = (float)i / k.mB * 2.0f - 1.0f;
float tmp = std::abs(out[i]);
drawArray[2 * i + 1] = tmp;
max = std::max(tmp, max);
}
font = new Font(512, "res/font/DroidSans.woff", 32, tm);
print = new Print(font);
//print.set(&font, "res/shader/fontVertex.c", "res/shader/fontFragment.c");
print->setScreenSize(screen);
glm::vec2* vert = new glm::vec2[1024];
glm::vec2* debug = new glm::vec2[b.getWidth()];
for (unsigned int i = 0; i < b.getWidth(); ++i) {
debug[i].x = (float)i / b.getWidth() * 2.0f - 1.0f;
}
uint32_t vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
uint32_t vbo[2];
glGenBuffers(1, vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glEnableVertexAttribArray(0);
glBufferData(GL_ARRAY_BUFFER, k.mB * sizeof(glm::vec2), drawArray, GL_DYNAMIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_BLEND);
glfwSetWindowUserPointer(window, this);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
double time, timeo;
glfwSwapInterval(1);
PaStream* stream;
PaStreamParameters params;
params.device = 21;
params.channelCount = 1;
params.sampleFormat = paFloat32;
params.hostApiSpecificStreamInfo = nullptr;
params.suggestedLatency = 0.5;
err = Pa_OpenStream(&stream, ¶ms, nullptr, sampleRate, paFramesPerBufferUnspecified, 0, paCallback, this);
if (err != paNoError)
printf("error %i", err);
Pa_StartStream(stream);
while(!glfwWindowShouldClose(window))
{
timeo = time;
time = glfwGetTime();
CQT::transform(mAudioData, out, b, mAudioLength);
max = 0.0f;
for (unsigned int i = 0; i < k.mB; ++i) {
drawArray[2 * i + 0] = (float)i / k.mB * 2.0f - 1.0f;
float tmp = std::abs(out[i]);
drawArray[2 * i + 1] = tmp;
max = std::max(tmp, max);
}
for (unsigned int i = 0; i < k.mB; ++i) {
drawArray[2 * i + 1] = std::log(drawArray[2 * i +1]) * mScale + mOffset;
}
//printf("%f\n", drawArray[1]);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);
glBufferData(GL_ARRAY_BUFFER, k.mB * sizeof(glm::vec2), drawArray, GL_DYNAMIC_DRAW);
p->use();
glDrawArrays(GL_LINE_STRIP, 0, k.mB);
for (unsigned int i = 0; i < b.getWidth(); ++i) {
debug[i].y = mAudioData[i] / 15.0;
}
glBufferData(GL_ARRAY_BUFFER, b.getWidth() * sizeof(glm::vec2), debug, GL_DYNAMIC_DRAW);
glDrawArrays(GL_LINE_STRIP, 0, b.getWidth());
print->printfAt(-300.0f, 100.0f, 16.0f, 16.0f, u8"Fps:%03.3f", 1/(time-timeo));
glfwSwapBuffers(window);
glClear(GL_COLOR_BUFFER_BIT);
glfwPollEvents();
}
Pa_StopStream(stream);
Pa_CloseStream(stream);
Pa_Terminate();
std::cout << "Hello World. I'm Peach." << std::endl;
}
int main(void)
{
char pad[256];
PortAudioStream *stream;
PaError err;
const PaDeviceInfo *pdi;
paTestData data = {0};
printf("PortAudio Test: output sine wave on each channel.\n" );
err = Pa_Initialize();
if( err != paNoError ) goto error;
pdi = Pa_GetDeviceInfo( OUTPUT_DEVICE );
data.numChannels = pdi->maxOutputChannels;
if( data.numChannels > MAX_CHANNELS ) data.numChannels = MAX_CHANNELS;
printf("Number of Channels = %d\n", data.numChannels );
data.amplitude = 1.0;
err = Pa_OpenStream(
&stream,
paNoDevice, /* default input device */
0, /* no input */
paFloat32, /* 32 bit floating point input */
NULL,
OUTPUT_DEVICE,
data.numChannels,
paFloat32, /* 32 bit floating point output */
NULL,
SAMPLE_RATE,
FRAMES_PER_BUFFER, /* frames per buffer */
0, /* number of buffers, if zero then use default minimum */
paClipOff, /* we won't output out of range samples so don't bother clipping them */
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
do
{
printf("Current amplitude = %f\n", data.amplitude );
printf("Enter new amplitude or 'q' to quit.\n");
fflush(stdout);
gets( pad );
if( pad[0] != 'q' )
{
// I tried to use atof but it seems to be broken on Mac OS X 10.1
float amp;
sscanf( pad, "%f", & );
data.amplitude = amp;
}
} while( pad[0] != 'q' );
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
Pa_CloseStream( stream );
Pa_Terminate();
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
int main(int argc, char* argv[])
{
PaStreamParameters outputParameters;
PaWinMmeStreamInfo wmmeStreamInfo;
PaStream *stream;
PaError err;
paTestData data;
int deviceIndex;
FILE *fp;
const char *fileName = "c:\\test_48k.ac3.spdif";
data.buffer = NULL;
printf("usage: patest_wmme_ac3 fileName [paDeviceIndex]\n");
printf("**IMPORTANT*** The provided file must include the spdif preamble at the start of every AC-3 frame. Using a normal ac3 file won't work.\n");
printf("PortAudio Test: output a raw spdif ac3 stream. SR = %d, BufSize = %d, Chans = %d\n",
SAMPLE_RATE, FRAMES_PER_BUFFER, CHANNEL_COUNT);
if( argc >= 2 )
fileName = argv[1];
printf( "reading spdif ac3 raw stream file %s\n", fileName );
fp = fopen( fileName, "rb" );
if( !fp ){
fprintf( stderr, "error opening spdif ac3 file.\n" );
return -1;
}
/* get file size */
fseek( fp, 0, SEEK_END );
data.bufferSampleCount = ftell( fp ) / sizeof(short);
fseek( fp, 0, SEEK_SET );
/* allocate buffer, read the whole file into memory */
data.buffer = (short*)malloc( data.bufferSampleCount * sizeof(short) );
if( !data.buffer ){
fprintf( stderr, "error allocating buffer.\n" );
return -1;
}
fread( data.buffer, sizeof(short), data.bufferSampleCount, fp );
fclose( fp );
data.playbackIndex = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
deviceIndex = Pa_GetHostApiInfo( Pa_HostApiTypeIdToHostApiIndex( paMME ) )->defaultOutputDevice;
if( argc >= 3 ){
sscanf( argv[1], "%d", &deviceIndex );
}
printf( "using device id %d (%s)\n", deviceIndex, Pa_GetDeviceInfo(deviceIndex)->name );
outputParameters.device = deviceIndex;
outputParameters.channelCount = CHANNEL_COUNT;
outputParameters.sampleFormat = paInt16; /* IMPORTANT must use paInt16 for WMME AC3 */
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
wmmeStreamInfo.size = sizeof(PaWinMmeStreamInfo);
wmmeStreamInfo.hostApiType = paMME;
wmmeStreamInfo.version = 1;
wmmeStreamInfo.flags = paWinMmeWaveFormatDolbyAc3Spdif;
outputParameters.hostApiSpecificStreamInfo = &wmmeStreamInfo;
if( Pa_IsFormatSupported( 0, &outputParameters, SAMPLE_RATE ) == paFormatIsSupported ){
printf( "Pa_IsFormatSupported reports device will support %d channels.\n", CHANNEL_COUNT );
}else{
printf( "Pa_IsFormatSupported reports device will not support %d channels.\n", CHANNEL_COUNT );
}
err = Pa_OpenStream(
&stream,
NULL, /* no input */
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
0,
patestCallback,
&data );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Play for %d seconds.\n", NUM_SECONDS );
Pa_Sleep( NUM_SECONDS * 1000 );
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
free( data.buffer );
printf("Test finished.\n");
return err;
error:
Pa_Terminate();
free( data.buffer );
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
int main(int argc, char* argv[]){
char* host = "127.0.0.1";
if (argc != 2){
std::cerr << "Usage: client <host>" << std::endl;
return 1;
}else{
host = argv[1];
}
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
sAudioBuffer* audiobuf;
audiobuf = new sAudioBuffer();
audiobuf->dec = opus_decoder_create(SAMPLE_RATE, 2, &audiobuf->error);
if(audiobuf->error != OPUS_OK){
std::cerr << "opus: could not create decoder" << std::endl;
return 2;
}
printf("SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER);
audiobuf->readerIndex = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice();
if (outputParameters.device == paNoDevice){
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2;
outputParameters.sampleFormat = paFloat32;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL,
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff,
audioCallback,
audiobuf);
if( err != paNoError ) goto error;
err = Pa_SetStreamFinishedCallback( stream, &StreamFinished );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
try{
serveClient(host, audiobuf);
}catch (std::exception& e){
std::cerr << e.what() << std::endl;
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
delete audiobuf;
return 0;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
PaError TestRecording( paTestData *dataPtr )
{
PortAudioStream *stream;
PaError err;
int i;
/* Record some audio. */
err = Pa_OpenStream(
&stream,
Pa_GetDefaultInputDeviceID(),
dataPtr->samplesPerFrame, /* stereo input */
PA_SAMPLE_TYPE,
NULL,
paNoDevice,
0,
PA_SAMPLE_TYPE,
NULL,
SAMPLE_RATE,
FRAMES_PER_BUFFER, /* frames per buffer */
NUM_REC_BUFS, /* number of buffers, if zero then use default minimum */
paClipOff, /* we won't output out of range samples so don't bother clipping them */
recordCallback,
dataPtr );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
printf("Now recording!\n"); fflush(stdout);
for( i=0; i<(NUM_SECONDS*1000/SLEEP_DUR_MSEC); i++ )
{
if( Pa_StreamActive( stream ) <= 0)
{
printf("Stream inactive!\n");
break;
}
if( dataPtr->maxFrameIndex <= dataPtr->frameIndex )
{
printf("Buffer recording complete.\n");
break;
}
Pa_Sleep(100);
printf("index = %d\n", dataPtr->frameIndex ); fflush(stdout);
}
printf("Finished loop. Close stream.\n"); fflush(stdout);
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
printf("Done.\n"); fflush(stdout);
{
SAMPLE max = 0;
SAMPLE posVal;
int i;
for( i=0; i<dataPtr->numSamples; i++ )
{
posVal = dataPtr->recordedSamples[i];
if( posVal < 0 ) posVal = -posVal;
if( posVal > max ) max = posVal;
}
printf("Largest recorded sample = %d\n", max );
}
/* Write recorded data to a file. */
#if 0
{
FILE *fid;
fid = fopen("recorded.raw", "wb");
if( fid == NULL )
{
printf("Could not open file.");
}
else
{
fwrite( dataPtr->recordedSamples, dataPtr->samplesPerFrame * sizeof(SAMPLE), totalFrames, fid );
fclose( fid );
printf("Wrote data to 'recorded.raw'\n");
}
}
#endif
error:
return err;
}