int AudioStreamManager::StreamAudio(ISoundDelegate* delegate) { PaStreamParameters inputParameters, outputParameters; PaError err; soundDelegate = delegate; 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 = 2; /* stereo 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 = 2; /* stereo output */ outputParameters.sampleFormat = PA_SAMPLE_TYPE; outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputParameters.device)->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; err = Pa_OpenStream( &audioStream, &inputParameters, &outputParameters, SAMPLE_RATE, FRAMES_PER_BUFFER, 0, /* paClipOff, */ /* we won't output out of range samples so don't bother clipping them */ readStreamCallback, NULL); if (err != paNoError) goto error; delegate->willBeginPlay(); err = Pa_StartStream(audioStream); if (err != paNoError) goto error; 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)); delegate->didEndPlay(); return -1; }
void GuitarSori::init( const int mFramesPerBuffer, const int mNumChannels, const int mSampleSize, PaSampleFormat mSampleFormat, const double mSampleRate) { int numBytes, numBytesConverted; framesPerBuffer = mFramesPerBuffer; numChannels = mNumChannels; sampleSize = mSampleSize; sampleFormat = mSampleFormat; sampleRate = mSampleRate; numBytes = mFramesPerBuffer * mNumChannels * mSampleSize; numBytesConverted = mFramesPerBuffer * mNumChannels * 8; freeBuffers(); sampleBlock = (char *)malloc(numBytes); sampleBlockConverted = (double *)malloc(numBytesConverted); sampleBlockFFT = (double *)malloc(numBytesConverted / 2); if ( !isBuffersReady() ) { printf("Cannot allocate sample block\n"); return; } memset(sampleBlock, 0x00, numBytes); memset(sampleBlockConverted, 0x00, numBytesConverted); memset(sampleBlockFFT, 0x00, numBytesConverted / 2); err = Pa_Initialize(); printf("──────────────────────────────\n"); inputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */ inputParameters.device = 1; printf("Input device # %d. : %s\n", inputParameters.device, Pa_GetDeviceInfo(inputParameters.device)->name); printf("Input LL: %g s\n", Pa_GetDeviceInfo(inputParameters.device)->defaultLowInputLatency); printf("Input HL: %g s\n", Pa_GetDeviceInfo(inputParameters.device)->defaultHighInputLatency); printf("Input HL: %g s\n", Pa_GetDeviceInfo(inputParameters.device)->defaultHighInputLatency); printf("Input Channel(MAX.) : %d ", Pa_GetDeviceInfo(inputParameters.device)->maxInputChannels); inputParameters.channelCount = numChannels; inputParameters.sampleFormat = sampleFormat; inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputParameters.device)->defaultHighInputLatency; inputParameters.hostApiSpecificStreamInfo = NULL; outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ printf("Output device # %d.\n", outputParameters.device); printf("Output LL: %g s\n", Pa_GetDeviceInfo(outputParameters.device)->defaultLowOutputLatency); printf("Output HL: %g s\n", Pa_GetDeviceInfo(outputParameters.device)->defaultHighOutputLatency); outputParameters.channelCount = numChannels; outputParameters.sampleFormat = sampleFormat; outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputParameters.device)->defaultHighOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; err = Pa_OpenStream(&stream, &inputParameters, &outputParameters, sampleRate, framesPerBuffer, paClipOff, NULL, NULL); err = Pa_StartStream(stream); }
int main(void) { PaStreamParameters outputParameters; PaStream *stream; PaError err; paTestData data; int i; printf("PortAudio Test: output sine wave.\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; err = Pa_Initialize(); if( err != paNoError ) goto error; outputParameters.device = Pa_GetDefaultOutputDevice(); /* default 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, /* As above. */ SAMPLE_RATE, 256, /* Frames per buffer. */ paClipOff, /* No out of range samples expected. */ patestCallback, &data ); 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; 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 int init_media_processing(avdtp_media_codec_configuration_sbc_t configuration){ int num_channels = configuration.num_channels; int sample_rate = configuration.sampling_frequency; #ifdef DECODE_SBC btstack_sbc_decoder_init(&state, mode, handle_pcm_data, NULL); #endif #ifdef STORE_SBC_TO_WAV_FILE wav_writer_open(wav_filename, num_channels, sample_rate); #endif #ifdef STORE_SBC_TO_SBC_FILE sbc_file = fopen(sbc_filename, "wb"); #endif #ifdef HAVE_PORTAUDIO // int frames_per_buffer = configuration.frames_per_buffer; PaError err; PaStreamParameters outputParameters; /* -- initialize PortAudio -- */ err = Pa_Initialize(); if (err != paNoError){ printf("Error initializing portaudio: \"%s\"\n", Pa_GetErrorText(err)); return err; } /* -- setup input and output -- */ outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ outputParameters.channelCount = num_channels; outputParameters.sampleFormat = PA_SAMPLE_TYPE; outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultHighOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; /* -- setup stream -- */ err = Pa_OpenStream( &stream, NULL, /* &inputParameters */ &outputParameters, sample_rate, 0, paClipOff, /* we won't output out of range samples so don't bother clipping them */ patestCallback, /* use callback */ NULL ); if (err != paNoError){ printf("Error initializing portaudio: \"%s\"\n", Pa_GetErrorText(err)); return err; } memset(ring_buffer_storage, 0, sizeof(ring_buffer_storage)); btstack_ring_buffer_init(&ring_buffer, ring_buffer_storage, sizeof(ring_buffer_storage)); pa_stream_started = 0; #endif media_initialized = 1; return 0; }
void handle_sound(adata_t *data) { PaStream *stream; PaError error; PaStreamParameters outputParameters; /* initialize our data structure */ data->position = 0; data->thread_idle = 0; data->sfInfo.format = SF_FORMAT_OGG; /* try to open the file */ data->sndFile = sf_open(data->filepath, SFM_READ, &data->sfInfo); if (!data->sndFile) { printf("error opening file\n"); exit(1); } /* start portaudio */ Pa_Initialize(); /* set the output parameters */ outputParameters.device = Pa_GetDefaultOutputDevice(); /* use the default device */ outputParameters.channelCount = data->sfInfo.channels; /* use the same number of channels as our sound file */ outputParameters.sampleFormat = paInt32; /* 32bit int format */ outputParameters.suggestedLatency = 0.2; /* 200 ms ought to satisfy even the worst sound card */ outputParameters.hostApiSpecificStreamInfo = 0; /* no api specific data */ /* try to open the output */ error = Pa_OpenStream(&stream, /* stream is a 'token' that we need to save for future portaudio calls */ 0, /* no input */ &outputParameters, data->sfInfo.samplerate, /* use the same sample rate as the sound file */ paFramesPerBufferUnspecified, /* let portaudio choose the buffersize */ paNoFlag, /* no special modes (clip off, dither off) */ Callback, /* callback function defined above */ data ); /* pass in our data structure so the callback knows what's up */ /* if we can't open it, then bail out */ if (error) { printf("error opening output, error code = %i\n", error); Pa_Terminate(); } /* when we start the stream, the callback starts getting called */ Pa_StartStream(stream); long ms_length = ((double)data->sfInfo.frames / (double)data->sfInfo.samplerate) * 1000.; Pa_Sleep(ms_length); Pa_CloseStream(stream); // stop the stream (*data).thread_complete = 1; Pa_Terminate(); // and shut down portaudio }
int main() { SndData *data = (SndData *)malloc(sizeof(SndData)); PaStream *stream; PaError error; PaStreamParameters outputParameters; /* initialize our data structure */ data->position = 0; data->sfInfo.format = 0; /* try to open the file */ data->sndFile = sf_open(FILE_NAME, SFM_READ, &data->sfInfo); if (!data->sndFile) { printf("error opening file\n"); return 1; } /* start portaudio */ Pa_Initialize(); /* set the output parameters */ outputParameters.device = Pa_GetDefaultOutputDevice(); /* use the default device */ outputParameters.channelCount = data->sfInfo.channels; /* use the same number of channels as our sound file */ outputParameters.sampleFormat = paInt32; /* 32bit int format */ outputParameters.suggestedLatency = 0.01; /* 10 ms latency, if possible */ outputParameters.hostApiSpecificStreamInfo = 0; /* no api specific data */ /* try to open the output */ error = Pa_OpenStream(&stream, /* stream is a 'token' that we need to save for future portaudio calls */ 0, /* no input */ &outputParameters, data->sfInfo.samplerate, /* use the same sample rate as the sound file */ paFramesPerBufferUnspecified, /* let portaudio choose the buffersize */ paNoFlag, /* no special modes (clip off, dither off) */ Callback, /* callback function defined above */ data ); /* pass in our data structure so the callback knows what's up */ /* if we can't open it, then bail out */ if (error) { printf("error opening output, error code = %i\n", error); Pa_Terminate(); return 1; } /* when we start the stream, the callback starts getting called */ Pa_StartStream(stream); Pa_Sleep(2000); /* pause for 2 seconds (2000ms) so we can hear a bit of the output */ Pa_StopStream(stream); // stop the stream Pa_Terminate(); // and shut down portaudio return 0; }
int test(short interleaved) { PaStream* stream; PaStreamParameters outputParameters; PaError err; const PaDeviceInfo* pdi; paTestData data; short n; outputParameters.device = Pa_GetDefaultOutputDevice(); /* Default output device, max channels. */ pdi = Pa_GetDeviceInfo(outputParameters.device); outputParameters.channelCount = pdi->maxOutputChannels; if (outputParameters.channelCount > MAX_CHANNELS) outputParameters.channelCount = MAX_CHANNELS; outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */ outputParameters.suggestedLatency = pdi->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; data.interleaved = interleaved; data.numChannels = outputParameters.channelCount; for (n = 0; n < data.numChannels; n++) data.phases[n] = 0.0; /* Phases wrap and maybe don't need initialisation. */ printf("%d ", data.numChannels); if (interleaved) printf("interleaved "); else { printf(" non-interleaved "); outputParameters.sampleFormat |= paNonInterleaved; } printf("channels.\n"); err = Pa_OpenStream(&stream, NULL, /* No input. */ &outputParameters, SAMPLE_RATE, /* Sample rate. */ FRAMES_PER_BUFFER, /* Frames per buffer. */ paClipOff, /* Samples never out of range, no clipping. */ patestCallback, &data); if (err == paNoError) { err = Pa_StartStream(stream); if (err == paNoError) { printf("Hit ENTER to stop this test.\n"); getchar(); err = Pa_StopStream(stream); } Pa_CloseStream( stream ); } return err; }
static int quisk_pa_name2index (struct sound_dev * dev, int is_capture) { // Based on the device name, set the portaudio index, or -1. // Return non-zero for error. Not a portaudio device is not an error. const PaDeviceInfo * pInfo; int i, count; if (strncmp (dev->name, "portaudio", 9)) { dev->portaudio_index = -1; // Name does not start with "portaudio" return 0; // Not a portaudio device, not an error } if ( ! strcmp (dev->name, "portaudiodefault")) { if (is_capture) // Fill in the default device index dev->portaudio_index = Pa_GetDefaultInputDevice(); else dev->portaudio_index = Pa_GetDefaultOutputDevice(); strncpy (dev->msg1, "Using default portaudio device", QUISK_SC_SIZE); return 0; } if ( ! strncmp (dev->name, "portaudio#", 10)) { // Integer index follows "#" dev->portaudio_index = i = atoi(dev->name + 10); pInfo = Pa_GetDeviceInfo(i); if (pInfo) { snprintf (dev->msg1, QUISK_SC_SIZE, "PortAudio device %s", pInfo->name); return 0; } else { snprintf (quisk_sound_state.err_msg, QUISK_SC_SIZE, "Can not find portaudio device number %s", dev->name + 10); } return 1; } if ( ! strncmp (dev->name, "portaudio:", 10)) { dev->portaudio_index = -1; count = Pa_GetDeviceCount(); // Search for string in device name for (i = 0; i < count; i++) { pInfo = Pa_GetDeviceInfo(i); if (pInfo && strstr(pInfo->name, dev->name + 10)) { dev->portaudio_index = i; snprintf (dev->msg1, QUISK_SC_SIZE, "PortAudio device %s", pInfo->name); break; } } if (dev->portaudio_index == -1) { // Error snprintf (quisk_sound_state.err_msg, QUISK_SC_SIZE, "Can not find portaudio device named %s", dev->name + 10); return 1; } return 0; } snprintf (quisk_sound_state.err_msg, QUISK_SC_SIZE, "Did not recognize portaudio device %s", dev->name); return 1; }
static int pa_setsp(rsound *rsnd, PaStreamParameters *sp) { sp->device = Pa_GetDefaultOutputDevice(); if (sp->device == paNoDevice) { return -1; } sp->channelCount = 2; /* stereo output */ sp->sampleFormat = paFloat32; /* 32bit floating point output */ sp->suggestedLatency = Pa_GetDeviceInfo(sp->device)->defaultLowOutputLatency; return 0; }
bool PortAudio::open(long rate, int channels) { if(mRate != rate || mChannels != channels) { close(); } if(!isOpen) { //PaDeviceIndex default_device = 2; PaDeviceIndex default_device = Pa_GetDefaultOutputDevice(); if( default_device == paNoDevice ) { LOG4CXX_ERROR(narratorPaLog, "Pa_GetDefaultOutputDevice failed, however, device count is: " << Pa_GetDeviceCount() ); return false; } mOutputParameters.device = default_device; /* default output device */ mOutputParameters.channelCount = channels; mOutputParameters.sampleFormat = paFloat32; mOutputParameters.suggestedLatency = Pa_GetDeviceInfo( mOutputParameters.device )->defaultHighOutputLatency; mOutputParameters.hostApiSpecificStreamInfo = NULL; const PaDeviceInfo* devinfo = Pa_GetDeviceInfo(mOutputParameters.device); const PaHostApiInfo* hostapiinfo = Pa_GetHostApiInfo(devinfo->hostApi); LOG4CXX_DEBUG(narratorPaLog, "Opening device: " << devinfo->name << " (" << hostapiinfo->name << "), channels: " << channels << ", rate: " << rate <<" (" << devinfo->defaultSampleRate << ")"); unsigned long framesPerBuffer = 1024; #ifdef WIN32 framesPerBuffer = 4096; #endif mError = Pa_OpenStream(&pStream, NULL, &mOutputParameters, rate, framesPerBuffer/*paFramesPerBufferUnspecified*/, paNoFlag, pa_stream_callback, this); if(mError != paNoError) { LOG4CXX_ERROR(narratorPaLog, "Failed to open stream: " << Pa_GetErrorText(mError)); return false; } mRate = rate; mChannels = channels; isOpen = true; isStarted = false; mError = Pa_SetStreamFinishedCallback(pStream, pa_stream_finished_callback); if(mError != paNoError) { LOG4CXX_ERROR(narratorPaLog, "Failed to set FinishedCallback: " << Pa_GetErrorText(mError)); } } return true; }
PaError TestOnce( int buffersize, PaDeviceIndex device ) { PaStreamParameters outputParameters; PaStream *stream; PaError err; paTestData data; int i; int totalSamps; /* initialise sinusoidal wavetable */ for( i=0; i<TABLE_SIZE; i++ ) { data.sine[i] = (short) (32767.0 * sin( ((double)i/(double)TABLE_SIZE) * M_PI * 2. )); } data.left_phase = data.right_phase = 0; data.sampsToGo = totalSamps = NUM_SECONDS * SAMPLE_RATE; /* Play for a few seconds. */ err = Pa_Initialize(); if( err != paNoError ) goto error; if( device == -1 ) outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ else outputParameters.device = device ; outputParameters.channelCount = 2; /* stereo output */ outputParameters.sampleFormat = paInt16; /* 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, buffersize, /* frames per buffer */ (paClipOff | paDitherOff), patest1Callback, &data ); if( err != paNoError ) goto error; err = Pa_StartStream( stream ); if( err != paNoError ) goto error; printf("Waiting for sound to finish.\n"); Pa_Sleep(1000*NUM_SECONDS); err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; Pa_Terminate(); return paNoError; 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 ) ); fprintf( stderr, "Host Error message: %s\n", Pa_GetLastHostErrorInfo()->errorText ); return err; }
int main(void) { PaStream *stream; PaStreamParameters outputParameters; PaError err; paTestData data; int totalSamps; printf("PortAudio Test: output " FORMAT_NAME "\n"); data.left_phase = data.right_phase = 0.0; data.framesToGo = totalSamps = NUM_SECONDS * SAMPLE_RATE; /* Play for a few seconds. */ err = Pa_Initialize(); if( err != paNoError ) goto error; outputParameters.device = Pa_GetDefaultOutputDevice(); /* Default output device. */ outputParameters.channelCount = 2; /* Stereo output */ outputParameters.sampleFormat = TEST_FORMAT; /* Selected above. */ 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("Waiting %d seconds for sound to finish.\n", NUM_SECONDS ); while( ( err = Pa_IsStreamActive( stream ) ) == 1 ) Pa_Sleep(100); if( err < 0 ) goto error; err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; Pa_Terminate(); printf("PortAudio Test Finished: " FORMAT_NAME "\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, const char ** argv ) { PaStreamParameters outputParameters; PaError pa_err; SF_INFO sfinfo; int i; for (i = 1; i < argc; i++) { if (!strncmp(argv[i], "-m", 2)) { mute = 1; } if (!strncmp(argv[i], "-o", 2)) { to_stdout = 1; } } gen_default_drums(); pa_err = Pa_Initialize(); outputParameters.device = Pa_GetDefaultOutputDevice(); outputParameters.channelCount = CHANNELS; outputParameters.sampleFormat = paFloat32; outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = NULL; pa_err = Pa_OpenStream( &stream, NULL, &outputParameters, SAMPLE_RATE, BUFFER_SIZE, paClipOff, audio_callback, NULL ); sfinfo.samplerate = SAMPLE_RATE; sfinfo.channels = CHANNELS; sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_FLOAT; wave_output = sf_open( OUTPUT_FILE, SFM_WRITE, &sfinfo ); convert_buf = (int32_t*)malloc(SAMPLE_RATE * 4 * 2); srand( time( 0 ) ); bass_z = 0.0f; bass_freq = midi_to_hz( BASE_NOTE ); pa_err = Pa_StartStream( stream ); while( 1 ) Pa_Sleep( 10000 ); sf_close( wave_output ); pa_err = Pa_StopStream( stream ); pa_err = Pa_CloseStream( stream ); Pa_Terminate(); return 0; }
int main(void) { 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; err = Pa_OpenStream( &stream, paNoDevice,/* default input device */ 0, /* no input */ paFloat32, /* 32 bit floating point input */ 0, /* default latency */ NULL, Pa_GetDefaultOutputDevice(), /* default output device */ 2, /* stereo output */ paFloat32, /* 32 bit floating point output */ 0, /* default latency */ NULL, 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 %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; }
PaDeviceIndex SoundcardDialog::getOutputSource() { int index = ui->outputComboBox->currentIndex(); if (index == -1) { // no item was selected, so we return the // default input device return Pa_GetDefaultOutputDevice(); } else { bool ok; PaDeviceIndex idx = ui->outputComboBox->itemData(index).toInt(&ok); if (!ok) { // conversion to int not succesfull // return the default input device .. :( return Pa_GetDefaultOutputDevice(); } return idx; } }
/** * Initializes the output parameters for playback * * Function will initailize all the members of the passed * in PaStreamParameters struct. * @param out_pars a pointer to a PaStreamParameters struct. * @param format the sample format for the output device to use */ void setupDefaultOutputParameters( PaStreamParameters *out_pars, PaSampleFormat format) { out_pars->device = Pa_GetDefaultOutputDevice(); if (out_pars->device == paNoDevice) fatal_terminate("No default output device"); out_pars->channelCount = Pa_GetDeviceInfo(out_pars->device)-> maxOutputChannels; out_pars->sampleFormat = format; out_pars->suggestedLatency = Pa_GetDeviceInfo(out_pars->device)->defaultLowOutputLatency; out_pars->hostApiSpecificStreamInfo = NULL; }
LVAL prepare_audio(LVAL play, SF_INFO *sf_info, PaStream **audio_stream) { PaStreamParameters output_parameters; int i; int num_devices; const PaDeviceInfo *device_info; const PaHostApiInfo *host_info; if (!portaudio_initialized) { if (portaudio_error(Pa_Initialize(), "could not initialize portaudio")) { return NIL; } portaudio_initialized = TRUE; } output_parameters.device = Pa_GetDefaultOutputDevice(); output_parameters.channelCount = sf_info->channels; output_parameters.sampleFormat = paFloat32; output_parameters.hostApiSpecificStreamInfo = NULL; /* remember that Nyquist has to do GC */ output_parameters.suggestedLatency = sound_latency; // Initialize the audio stream for output // If this is Linux, prefer to open ALSA device num_devices = Pa_GetDeviceCount(); for (i = 0; i < num_devices; i++) { device_info = Pa_GetDeviceInfo(i); host_info = Pa_GetHostApiInfo(device_info->hostApi); if (host_info->type == paALSA) { output_parameters.device = i; break; } } if (portaudio_error( Pa_OpenStream(audio_stream, NULL /* input */, &output_parameters, sf_info->samplerate, max_sample_block_len, paClipOff, NULL /* callback */, NULL /* userdata */), "could not open audio")) { return NIL; } flush_count = (long) (sf_info->samplerate * (sound_latency + 0.2)); if (portaudio_error(Pa_StartStream(*audio_stream), "could not start audio")) { return NIL; } return play; }
// play a module using portaudio. void play(DUH *duh) { // init portaudio, redirecting stderr output temporarily; a lot of junk // gets printed otherwise. this won't work on windows, but who cares? int old_stderr = dup(2); int new_stderr = open("/dev/null", O_WRONLY); dup2(new_stderr, 2); PaError err = Pa_Initialize(); close(new_stderr); dup2(old_stderr, 2); close(old_stderr); if (err != paNoError) die("could not init PortAudio: %s\n", Pa_GetErrorText(err)); atexit(&pa_terminate); // get default device info PaDeviceIndex index = Pa_GetDefaultOutputDevice(); if (index == paNoDevice) die("could not get default output device\n"); callback_data cd; const PaDeviceInfo *dev = Pa_GetDeviceInfo(index); cd.sample_rate = dev->defaultSampleRate; cd.delta = 65536.0f / cd.sample_rate; // open and start output stream PaStream *stream; cd.sr = duh_start_sigrenderer(duh, 0, channels, 0); err = Pa_OpenDefaultStream(&stream, 0, channels, paInt16, dev->defaultSampleRate, paFramesPerBufferUnspecified, callback, &cd); if (err != paNoError) { duh_end_sigrenderer(cd.sr); unload_duh(duh); die("could not open default stream: %s\n", Pa_GetErrorText(err)); } if ((err = Pa_StartStream(stream)) != paNoError) { duh_end_sigrenderer(cd.sr); unload_duh(duh); die("could not start stream: %s\n", Pa_GetErrorText(err)); } init_sigrenderer(cd.sr); // play while (Pa_IsStreamActive(stream) == 1) Pa_Sleep(100); // clean up Pa_CloseStream(stream); duh_end_sigrenderer(cd.sr); }
static PaError DoTest( int flags ) { PaStream *stream; PaError err = paNoError; paTestData data; PaStreamParameters outputParameters; InitializeTestData( &data ); outputParameters.device = Pa_GetDefaultOutputDevice(); if (outputParameters.device == paNoDevice) { fprintf(stderr,"Error: No default output device.\n"); goto error; } outputParameters.channelCount = 2; outputParameters.hostApiSpecificStreamInfo = NULL; outputParameters.sampleFormat = paFloat32; outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultHighOutputLatency; /* Open an audio I/O stream. */ err = Pa_OpenStream( &stream, NULL, /* no input */ &outputParameters, SAMPLE_RATE, FRAMES_PER_BUFFER, /* frames per buffer */ paClipOff | flags, /* 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("hear \"BEEP\"\n" ); fflush(stdout); while( ( err = Pa_IsStreamActive( stream ) ) == 1 ) Pa_Sleep(SLEEP_MSEC); if( err < 0 ) goto error; err = Pa_StopStream( stream ); if( err != paNoError ) goto error; err = Pa_CloseStream( stream ); if( err != paNoError ) goto error; return err; error: return err; }
void PortAudioHelper::loadDevices() { DEVICE_COUNT = Pa_GetDeviceCount(); DEFAULT_INPUT_DEVICE = Pa_GetDefaultInputDevice(); DEFAULT_OUTPUT_DEVICE = Pa_GetDefaultOutputDevice(); for (PaDeviceIndex i=0; i<DEVICE_COUNT; i++) { AudioDeviceInfo deviceInfo; deviceInfo.deviceInfo = *Pa_GetDeviceInfo(i); deviceInfo.supportedSampleRates = getSupportedSampleRate(i); DEVICES.append(deviceInfo); } CURRENT_INPUT_DEVICE = loadFromSettings(keyDefaultInputDevice, DEFAULT_INPUT_DEVICE).toInt(); CURRENT_OUTPUT_DEVICE = loadFromSettings(keyDefaultOutputDevice, DEFAULT_OUTPUT_DEVICE).toInt(); }
int SoundIO::init_sound(int achannels) { this->channels = achannels; PaStreamParameters outputParameters; PaError err; // initialize audio err = Pa_Initialize(); if( err != paNoError ) return 1; std::cout << "Initialized Portaudio." << std::endl; outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ outputParameters.channelCount = channels; outputParameters.sampleFormat = paFloat32; outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency; outputParameters.hostApiSpecificStreamInfo = nullptr; err = Pa_OpenStream( &stream, nullptr, /* no input */ &outputParameters, Fs, FRAMES_PER_BUFFER, paClipOff, nullptr, nullptr ); if( err != paNoError ) return 1; err = Pa_StartStream( stream ); if( err != paNoError ) return 1; std::cout << "Stream Opened" << std::endl; ////////////////////////// SF_INFO sfinfo; sfinfo.channels = channels; sfinfo.samplerate = Fs; //sfinfo.format = SF_FORMAT_OGG | SF_FORMAT_VORBIS; sfinfo.format = SF_FORMAT_WAV | SF_FORMAT_FLOAT; file = sf_open("sound.wav", SFM_WRITE, &sfinfo); std::cout << "File Opened" << std::endl; return 0; }
static PaDeviceIndex FindOutputOnlyDevice(void) { PaDeviceIndex result = Pa_GetDefaultOutputDevice(); if( result != paNoDevice && Pa_GetDeviceInfo(result)->maxInputChannels == 0 ) return result; for( result = 0; result < Pa_GetDeviceCount(); ++result ) { if( Pa_GetDeviceInfo(result)->maxInputChannels == 0 ) return result; } return paNoDevice; }
void *play(void *repeat_ptr) { int n; int *repeat = (int *)repeat_ptr; PaStreamParameters out_param; PaStream * stream; PaError err; SNDFILE * file; SF_INFO sfinfo; struct timespec tim, tim2; tim.tv_sec = 0; tim.tv_nsec = 500000000L; for (n=0; n<(*repeat); ++n) { file = sf_open("whistle.wav", SFM_READ, &sfinfo); printf("%d frames %d samplerate %d channels\n", (int)sfinfo.frames, sfinfo.samplerate, sfinfo.channels); /* init portaudio */ err = Pa_Initialize(); error_check(err); /* we are using the default device */ out_param.device = Pa_GetDefaultOutputDevice(); if (out_param.device == paNoDevice) fprintf(stderr, "Haven't found an audio device!\n"); /* stero or mono */ out_param.channelCount = sfinfo.channels; out_param.sampleFormat = paInt16; out_param.suggestedLatency = Pa_GetDeviceInfo(out_param.device)->defaultLowOutputLatency; out_param.hostApiSpecificStreamInfo = NULL; err = Pa_OpenStream(&stream, NULL, &out_param, sfinfo.samplerate, paFramesPerBufferUnspecified, paClipOff, output_cb, file); error_check(err); err = Pa_StartStream(stream); error_check(err); Pa_Sleep(800); err = Pa_StopStream(stream); error_check(err); err = Pa_CloseStream(stream); error_check(err); Pa_Terminate(); sf_close(file); nanosleep(&tim, &tim2); } is_playing=0; }
int main(int argc, char ** argv) { struct sigaction s; sigset_t ss; sigemptyset(&ss); s.sa_handler = &on_interrupt; sigemptyset(&s.sa_mask); s.sa_flags = 0; s.sa_restorer = NULL; sigaction(SIGINT, &s, NULL); PaDeviceIndex odev; PaDeviceInfo * odev_info; PaStreamParameters odev_p; PaStream * ostream; int bufsz = FRAMES_PER_BUFFER * CHANNELS * SAMPLE_SIZE; int bufrd = 0; int i; char * buf = (char*) malloc(bufsz); Pa_Initialize(); odev = Pa_GetDefaultOutputDevice(); odev_info = Pa_GetDeviceInfo(odev); odev_p.device = odev; odev_p.channelCount = CHANNELS; odev_p.sampleFormat = SAMPLE_TYPE; odev_p.suggestedLatency = odev_info->defaultLowOutputLatency; odev_p.hostApiSpecificStreamInfo = NULL; i = Pa_OpenStream(&ostream, NULL, &odev_p, SAMPLE_RATE, FRAMES_PER_BUFFER, paNoFlag, NULL, NULL); //printf("s = %d\n",i); Pa_StartStream(ostream); fd = open(argv[1], O_RDONLY); for (;;) { bufrd = 0; while (bufrd < bufsz) { i = read(fd, buf+bufrd, bufsz-bufrd); //printf("read %d\n", i); bufrd += i; if (i == 0) shutdown(1); } Pa_WriteStream(ostream, buf, FRAMES_PER_BUFFER); } }
void init() { PaError error; PaStreamParameters outputParameters; /* initialize our data structure */ this->positionFrame = 0; this->sfInfo.format = 0; /* try to open the file */ this->sndFile = sf_open(filename.c_str(), SFM_READ, &this->sfInfo); if (!this->sndFile) { printf("error opening file\n"); return; } duration = sfInfo.frames / sfInfo.samplerate; /* start portaudio */ Pa_Initialize(); /* set the output parameters */ /* use the default device */ outputParameters.device = Pa_GetDefaultOutputDevice(); /* use the same number of channels as our sound file */ outputParameters.channelCount = this->sfInfo.channels; // sfInfo.format /* 32bit int format */ outputParameters.sampleFormat = paInt32; /* 200 ms ought to satisfy even the worst sound card */ outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputParameters.device)->defaultHighOutputLatency; outputParameters.hostApiSpecificStreamInfo = 0; /* no api specific data */ /* try to open the output */ error = Pa_OpenStream(&stream, /* stream is a 'token' that we need to save for future portaudio calls */ 0, /* no input */ &outputParameters, sfInfo.samplerate, /* use the same sample rate as the sound file */ paFramesPerBufferUnspecified, /* let portaudio choose the buffersize */ paNoFlag, /* no special modes (clip off, dither off) */ _paCallBack, /* callback function defined above */ this); /* pass in our data structure so the callback knows what's up */ /* if we can't open it, then bail out */ if (error) { printf("error opening output, error code = %i\n", error); Pa_Terminate(); return; } _isInit = true; }
PaError PlaySine( paTestData *data, PaStreamFlags flags, float amplitude ) { PaStream* stream; PaStreamParameters outputParameters; PaError err; data->left_phase = data->right_phase = 0; data->amplitude = amplitude; err = Pa_Initialize(); if (err != paNoError) goto done; 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.hostApiSpecificStreamInfo = NULL; outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output. */ /* When you change this, also */ /* adapt the callback routine! */ outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device ) ->defaultLowOutputLatency; /* Low latency. */ err = Pa_OpenStream( &stream, NULL, /* No input. */ &outputParameters, SAMPLE_RATE, 1024, /* frames per buffer */ flags, sineCallback, (void*)data ); if (err != paNoError) goto done; err = Pa_StartStream( stream ); if (err != paNoError) goto done; Pa_Sleep( NUM_SECONDS * 1000 ); printf("CPULoad = %8.6f\n", Pa_GetStreamCpuLoad(stream)); err = Pa_CloseStream( stream ); done: Pa_Sleep( 250 ); /* Just a small silence. */ Pa_Terminate(); return err; }
bool PAudioStream::initOutput() { if (_buffer->output == NULL) return (false); if ((_outputParam.device = Pa_GetDefaultOutputDevice()) == paNoDevice) { qDebug() << "No default output device."; return (false); } _outputParam.channelCount = NUM_CHANNELS; _outputParam.sampleFormat = PA_SAMPLE_TYPE; _outputParam.suggestedLatency = (Pa_GetDeviceInfo(_outputParam.device))->defaultLowOutputLatency; _outputParam.hostApiSpecificStreamInfo = NULL; return (true); }
QString DevicePortAudio::deviceOutputDefaultName() { PaDeviceIndex DevIdx = Pa_GetDefaultOutputDevice(); if( DevIdx == paNoDevice ) { return( QString() ); } const PaDeviceInfo *DevInf = Pa_GetDeviceInfo( DevIdx ); const PaHostApiInfo *HstInf = Pa_GetHostApiInfo( DevInf->hostApi ); return( QString( "%1: %2" ).arg( HstInf->name ).arg( DevInf->name ) ); }
void AudioManager::initOutput() { if ((this->_outputParam.device = Pa_GetDefaultOutputDevice()) == paNoDevice) { this->errorAudio(); return ; } this->_outputParam.channelCount = 1; this->_outputParam.sampleFormat = PA_SAMPLE_TYPE; this->_outputParam.suggestedLatency = Pa_GetDeviceInfo(this->_outputParam.device)->defaultHighOutputLatency; this->_outputParam.hostApiSpecificStreamInfo = NULL; // std::cout << "Output device # " << this->_outputParam.device << std::endl; // std::cout << "Output LowLatency : " << Pa_GetDeviceInfo(this->_outputParam.device)->defaultLowOutputLatency << std::endl; // std::cout << "Output HighLatency : " << Pa_GetDeviceInfo(this->_outputParam.device)->defaultHighOutputLatency << std::endl; }
CPAManager::CPAManager(CRefPtr<Audio::IDriver> pDriver) : m_pDriver(pDriver), m_uDefaultIndex(0) { Log::Write(L"Initializing PortAudio Audio manager..."); auto uError = Pa_Initialize(); if(uError != paNoError){ CR_THROW(L"Failed to initialize port audio, Error: " + Utils::ToErrorString(uError)); } Log::Write(L"Enumerating audio adapters...", Log::LogLevel::Debug); auto uDeviceCount = Pa_GetDeviceCount(); for(PaDeviceIndex uIndex = 0; uIndex < uDeviceCount; uIndex++){ auto pInfo = Pa_GetDeviceInfo(uIndex); auto pApiInfo = Pa_GetHostApiInfo(pInfo->hostApi); auto strAdapter = String::FromANSI(reinterpret_cast<const int8*>(pInfo->name)); auto strHostApi = String::FromANSI(reinterpret_cast<const int8*>(pApiInfo->name)); strAdapter += L"[" + strHostApi + L"]"; Log::Write(L"Audio Adapter Found: " + strAdapter, Log::LogLevel::Debug); this->m_strAdapterList.Add(strAdapter); } Log::Write(L"End of enumeration of audio adapters.", Log::LogLevel::Debug); if(!this->m_strAdapterList.IsEmpty()){ Log::Write(L"Finding default audio adapter...", Log::LogLevel::Debug); auto uDefaultIndex = Pa_GetDefaultOutputDevice(); if(uDefaultIndex == paNoDevice){ Log::Write(L"Got null pointer for default device - assuming default as first in list."); uDefaultIndex = 0; } auto pInfo = Pa_GetDeviceInfo(uDefaultIndex); auto pApiInfo = Pa_GetHostApiInfo(pInfo->hostApi); auto strAdapter = String::FromANSI(reinterpret_cast<const int8*>(pInfo->name)); auto strHostApi = String::FromANSI(reinterpret_cast<const int8*>(pApiInfo->name)); strAdapter += L"[" + strHostApi + L"]"; Log::Write(L"Found default PortAudio adapter: " + strAdapter, Log::LogLevel::Debug); this->m_uDefaultIndex = uDefaultIndex; } }