本文整理汇总了C++中Pa_StartStream函数的典型用法代码示例。如果您正苦于以下问题：C++ Pa_StartStream函数的具体用法？C++ Pa_StartStream怎么用？C++ Pa_StartStream使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Pa_StartStream函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: RING_DBG
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();
}示例2: output_data
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)
//.........这里部分代码省略.........
示例3: run_filter
//.........这里部分代码省略.........
}
} 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示例4: main
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" );
//.........这里部分代码省略.........
示例5: newChain
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;
}示例6: Initialize
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";
}
//.........这里部分代码省略.........
示例7: main
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;
}示例8: Pa_Initialize
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");
}
}示例9: switch
/*!
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();
}示例10: main
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;
}示例11: startStream
void startStream(PaStream* stream) {
if(!stream) return;
PaError err = Pa_StartStream(stream);
if (err != paNoError)
Logger::logError("PortAudio error:") << Pa_GetErrorText(err) << endl;
}示例12: main
//.........这里部分代码省略.........
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;
}示例13: main
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");
//.........这里部分代码省略.........
示例14: OutStream
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;
}示例15: main
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;
}