C++ RtAudio类代码示例

int main()
{
  // Set the global sample rate before creating class instances.
  Stk::setSampleRate( 44100.0 );

  SineWave sine;
  RtAudio dac;

  // Figure out how many bytes in an StkFloat and setup the RtAudio stream.
  RtAudio::StreamParameters parameters;
  parameters.deviceId = dac.getDefaultOutputDevice();
  parameters.deviceId = 3;
  parameters.nChannels = 1;
  
  RtAudioFormat format = ( sizeof(StkFloat) == 8 ) ? RTAUDIO_FLOAT64 : RTAUDIO_FLOAT32;
  unsigned int bufferFrames = RT_BUFFER_SIZE;

  try {
    dac.openStream( &parameters, NULL, format, (unsigned int)Stk::sampleRate(),
		    &bufferFrames, &tick, (void *)&sine );
  }
  catch ( RtAudioError &error ) {
    error.printMessage();
    goto cleanup;
  }

  // configuration of oscilator
  sine.setFrequency(440.0);

  

  // start the main real time loop
  try {
    dac.startStream();
  }
  catch ( RtAudioError &error ) {
    error.printMessage();
    goto cleanup;
  }


  // USER interface

  // Block waiting here.
  char keyhit;
  std::cout << "\nPlaying ... press <enter> to quit.\n";
  std::cin.get( keyhit );

  // SYSTEM shutdown
  // Shut down the output stream.
  try {
    dac.closeStream();
  }
  catch ( RtAudioError &error ) {
    error.printMessage();
  }

 cleanup:
  return 0;
}

  void start(unsigned int bufferFrames = 512, unsigned int sampleRate = 44100) {
    this->bufferFrames = bufferFrames;
    this->sampleRate = sampleRate;

    if (dac.getDeviceCount() < 1) {
      std::cout << "\nNo audio devices found!\n";
      exit(0);
    }

    parameters.deviceId = (id == 1) ? 0 : 1;
    RtAudio::DeviceInfo info;
    info = dac.getDeviceInfo(parameters.deviceId);
    std::cout << "device = " << info.name << std::endl;
    //parameters.deviceId = dac.getDefaultOutputDevice();
    parameters.nChannels = 2;
    parameters.firstChannel = 0;

//RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (default), No such file or directory.

    try {
      unsigned int got = bufferFrames;
      dac.openStream(&parameters, NULL, RTAUDIO_SINT16, sampleRate, &got, &process, (void *)&data);
      //dac.openStream(&parameters, NULL, RTAUDIO_FLOAT32, sampleRate, &got, &process, (void *)&data);
      dac.startStream();
      std::cout << "requested " << bufferFrames << " but got " << got << std::endl;
    } catch (RtAudioError &e) {
      e.printMessage();
      exit(0);
    }
  }

int callback( void *output_buffer, void *input_buffer, unsigned int n_buffer_frames,
	      double stream_time, RtAudioStreamStatus status, void *data )
{
  RtAudio *audio = (RtAudio *)data;
  unsigned int sample_rate = audio->getStreamSampleRate();

  for (unsigned int i = 0; i < n_buffer_frames * 2;) {
    
    double fm_offset = 0;
    if (g_fm_on) {
      double fm_increment =  (2.0 * M_PI) / sample_rate * g_fm_frequency;
      g_fm_phase += fm_increment;
      if (g_fm_phase > 2 * M_PI) {
	g_fm_phase -= 2 * M_PI;
      }
      fm_offset = g_active_fm_ugen(g_fm_phase, g_fm_width) * g_fm_index;
    }

    double increment =  (2.0 * M_PI) / sample_rate * (g_frequency + fm_offset);
    g_phase += increment;
    if (g_phase > 2 * M_PI) {
      g_phase -= 2 * M_PI;
    }
    double samp = g_active_ugen(g_phase, g_width);

    if (g_modulate_input) {
      samp = ((double *)input_buffer)[i / 2] * samp;
    }

    ((double *)output_buffer)[i++] = samp;
    ((double *)output_buffer)[i++] = samp;
  }

  return 0;
}

int main()
{
    RtAudio dac;
    if ( dac.getDeviceCount() == 0 ) exit( 0 );

    RtAudio::StreamParameters parameters;
    parameters.deviceId = dac.getDefaultOutputDevice();
    parameters.nChannels = 2;
    unsigned int sampleRate = 44100;
    unsigned int bufferFrames = 256; // 256 sample frames

    RtAudio::StreamOptions options;
    options.flags = RTAUDIO_NONINTERLEAVED;

    try {
        dac.openStream( &parameters, NULL, RTAUDIO_FLOAT32,
                        sampleRate, &bufferFrames, &myCallback, NULL, &options );
    }
    catch ( RtError& e ) {
        std::cout << '\n' << e.getMessage() << '\n' << std::endl;
        exit( 0 );
    }

    return 0;
}

void slgAudio::info(){
    RtAudio *audioTemp = NULL;
    audioTemp = new RtAudio();
    unsigned int devices = audioTemp->getDeviceCount();
    RtAudio::DeviceInfo info;
    
    for (int i=0;i<devices;i++){
        info = audioTemp->getDeviceInfo(i);
        // std::cout<<"default input: "<<m_audio->getDefaultInputDevice()<<std::endl;
        // std::cout<<"default output: "<<m_audio->getDefaultOutputDevice()<<std::endl;
        if (info.probed ==true){
            std::cout<<"----------------------------- Device "<<i<<" ---------------------------"<<std::endl;
            if (info.isDefaultInput)
                std::cout << "--Default Input"<<std::endl;
            if (info.isDefaultOutput)
                std::cout << "--Default Output"<<std::endl;      
            std::cout << "Name = " << info.name << '\n';
            std::cout << "Max Input Channels = " << info.inputChannels << '\n';
            std::cout << "Max Output Channels = " << info.outputChannels << '\n';
            std::cout << "Max Duplex Channels = " << info.duplexChannels << '\n';
        }
    }
    delete audioTemp;
    audioTemp = NULL;
}

/* returns 0 on failure */
int
start_audio(AudioCallback _callback, int sample_rate, void *data)
{
	if(audio.getDeviceCount() < 1) {
		std::cout << "No audio devices found!\n";
		return 0;
	}
	
	RtAudio::StreamParameters iparams, oparams;
	
	/* configure input (microphone) */
	iparams.deviceId = audio.getDefaultInputDevice();
	iparams.nChannels = 1;
	iparams.firstChannel = 0;
	
	/* configure output */
	oparams.deviceId = audio.getDefaultOutputDevice();
	oparams.nChannels = 2;
	oparams.firstChannel = 0;
	unsigned int bufferFrames = 256;
	
	callback = _callback;
	
	try {
		audio.openStream(&oparams, &iparams, RTAUDIO_FLOAT64 /* double */, sample_rate, &bufferFrames, &render, data);
		audio.startStream();
	} catch(RtError& e) {
		e.printMessage();
		return 0;
	}
	
	return 1;
}

bool Audio::openAudioInputDevice(unsigned int device)
{
    RtAudio::StreamParameters p;
    double data[2];
    unsigned int num = 0;
    if (inIsOpened) return false;
    for (unsigned int i=0; i<adc.getDeviceCount(); i++)
    {
        if (adc.getDeviceInfo(i).inputChannels)
        {
            if (device == num)
            {
                p.deviceId = i;
                break;
            }
            num++;
        }
    }
    p.firstChannel = 0;
    p.nChannels = 2;
    try
    {
        adc.openStream(NULL, &p, RTAUDIO_FLOAT32, sampleRate, &bufferFrames, &audioInputCallback, (void*)&data);
        adc.startStream();
    }
    catch (RtAudioError& e)
    {
        inError = e.getMessage();
        return false;
    }
    inBuffer=(float*)calloc(bufferFrames, sizeof(float));
    inIsOpened=true;
    return true;
}

//---------------------------------------------------------
void ofSoundStreamListDevices(){
	RtAudio *audioTemp = 0;
	try {
		audioTemp = new RtAudio();
	} catch (RtError &error) {
		error.printMessage();
	}
 	int devices = audioTemp->getDeviceCount();
	RtAudio::DeviceInfo info;
	for (int i=0; i< devices; i++) {
		try {
			info = audioTemp->getDeviceInfo(i);
		} catch (RtError &error) {
			error.printMessage();
			break;
		}
		std::cout << "device = " << i << " (" << info.name << ")\n";
		if (info.isDefaultInput) std::cout << "----* default ----* \n";
		std::cout << "maximum output channels = " << info.outputChannels << "\n";
		std::cout << "maximum input channels = " << info.inputChannels << "\n";
		std::cout << "-----------------------------------------\n";

	}
	delete audioTemp;
}

void av_audio_start() {
	av_audio_get();
	
	if (rta.isStreamRunning()) {
		rta.stopStream();
	}
	if (rta.isStreamOpen()) {
		// close it:
		rta.closeStream();
	}	
	
	unsigned int devices = rta.getDeviceCount();
	if (devices < 1) {
		printf("No audio devices found\n");
		return;
	}
	
	RtAudio::DeviceInfo info;
	RtAudio::StreamParameters iParams, oParams;
	
	printf("Available audio devices (%d):\n", devices);
	for (unsigned int i=0; i<devices; i++) {
		info = rta.getDeviceInfo(i);
		printf("Device %d: %dx%d (%d) %s\n", i, info.inputChannels, info.outputChannels, info.duplexChannels, info.name.c_str());
	}
	
	printf("device %d\n", audio.indevice);
	
	info = rta.getDeviceInfo(audio.indevice);
	printf("Using audio input %d: %dx%d (%d) %s\n", audio.indevice, info.inputChannels, info.outputChannels, info.duplexChannels, info.name.c_str());
	
	audio.inchannels = info.inputChannels;
	
	iParams.deviceId = audio.indevice;
	iParams.nChannels = audio.inchannels;
	iParams.firstChannel = 0;
	
	info = rta.getDeviceInfo(audio.outdevice);
	printf("Using audio output %d: %dx%d (%d) %s\n", audio.outdevice, info.inputChannels, info.outputChannels, info.duplexChannels, info.name.c_str());
	
	audio.outchannels = info.outputChannels;
	
	oParams.deviceId = audio.outdevice;
	oParams.nChannels = audio.outchannels;
	oParams.firstChannel = 0;

	RtAudio::StreamOptions options;
	//options.flags |= RTAUDIO_NONINTERLEAVED;
	options.streamName = "av";
	
	try {
		rta.openStream( &oParams, &iParams, RTAUDIO_FLOAT32, audio.samplerate, &audio.blocksize, &av_rtaudio_callback, NULL, &options );
		rta.startStream();
		printf("Audio started\n");
	}
	catch ( RtError& e ) {
		fprintf(stderr, "%s\n", e.getMessage().c_str());
	}
}

bool DeviceManager::getAudioDevices(bool input, std::vector<Device>& devs)
{
    devs.clear();

#if defined(ANDROID)
    // Under Android, we don't access the device file directly.
    // Arbitrary use 0 for the mic and 1 for the output.
    // These ids are used in MediaEngine::SetSoundDevices(in, out);
    // The strings are for human consumption.
    if (input) {
        devs.push_back(Device("audioin", "audiorecord", 0));
    } else {
        devs.push_back(Device("audioout", "audiotrack", 1));
    }
    return true;
#elif defined(HAVE_RTAUDIO)

    // Since we are using RtAudio for audio capture it's best to
    // use RtAudio to enumerate devices to ensure indexes match.
    RtAudio audio;

    // Determine the number of devices available
    auto ndevices = audio.getDeviceCount();
    TraceS(this) << "Get audio devices: " << ndevices << endl;

    // Scan through devices for various capabilities
    RtAudio::DeviceInfo info;
    for (unsigned i = 0; i <= ndevices; i++) {
        try {
            info = audio.getDeviceInfo(i);    // may throw RtAudioError

            TraceS(this) << "Device:"
                << "\n\tName: " << info.name
                << "\n\tOutput Channels: " << info.outputChannels
                << "\n\tInput Channels: " << info.inputChannels
                << "\n\tDuplex Channels: " << info.duplexChannels
                << "\n\tDefault Output: " << info.isDefaultOutput
                << "\n\tDefault Input: " << info.isDefaultInput
                << "\n\tProbed: " << info.probed
                << endl;

            if (info.probed == true && (
                (input && info.inputChannels > 0) ||
                (!input && info.outputChannels > 0))) {

                TraceS(this) << "Adding device: " << info.name << endl;
                Device dev((input ? "audioin" : "audioout"), i, info.name, "",
                    (input ? info.isDefaultInput : info.isDefaultOutput));
                devs.push_back(dev);
            }
        }
        catch (RtAudioError& e) {
            ErrorS(this) << "Cannot probe audio device: " << e.getMessage() << endl;
        }
    }

    return filterDevices(devs, kFilteredAudioDevicesName);
#endif
}

int main(int argc, const char * argv[])
{
    RtAudio dac;
    RtAudio::StreamParameters rtParams;
    rtParams.deviceId = dac.getDefaultOutputDevice();
    rtParams.nChannels = nChannels;
#if RASPI
    unsigned int sampleRate = 22000;
#else
    unsigned int sampleRate = 44100;
#endif
    unsigned int bufferFrames = 512; // 512 sample frames
    
    Tonic::setSampleRate(sampleRate);
    
    std::vector<Synth> synths;
    synths.push_back(*new BassDrum());
    synths.push_back(*new Snare());
    synths.push_back(*new HiHat());
    synths.push_back(*new Funky());
    
    // Test write pattern
    
    DrumMachine *drumMachine = new DrumMachine(synths);
    
    drumMachine->loadPattern(0);
    
    ControlMetro metro = ControlMetro().bpm(480);
    
    ControlCallback drumMachineTick = ControlCallback(&mixer, [&](ControlGeneratorOutput output){
        drumMachine->tick();
    }).input(metro);
    
    Generator mixedSignal;
    for(int i = 0; i < NUM_TRACKS; i++)
    {
        mixedSignal = mixedSignal + synths[i];
    }
    mixer.setOutputGen(mixedSignal);
    
    try
    {
        dac.openStream( &rtParams, NULL, RTAUDIO_FLOAT32, sampleRate, &bufferFrames, &renderCallback, NULL, NULL );
        dac.startStream();
        
        // Send a pointer to our global drumMachine instance
        // to the serial communications layer.
        listenForMessages( drumMachine );
        
        dac.stopStream();
    }
    catch ( RtError& e )
    {
        std::cout << '\n' << e.getMessage() << '\n' << std::endl;
        exit( 0 );
    }
    
    return 0;
}

const char* getAudioDeviceName(unsigned int deviceId) {
    RtAudio audio;
    std::string name = audio.getDeviceInfo(deviceId).name;
    unsigned long len = name.length();
    char* c = new char[len+1];
    memcpy(c, name.c_str(), len+1);
    return c;
}

 void stop() {
   try {
     // Stop the stream
     dac.stopStream();
   } catch (RtAudioError &e) {
     e.printMessage();
   }
   if (dac.isStreamOpen()) dac.closeStream();
 }

// サポートしているデバイスリストを表示
void listDevices() {
    RtAudio audio;
    
    unsigned int devices = audio.getDeviceCount();
    RtAudio::DeviceInfo info;
    
    for(unsigned int i=0; i<devices; i++) {
        info = audio.getDeviceInfo(i);
        
        std::cout << "============================" << std::endl;
        std::cout << "\nDevide ID:" << i << std::endl;
        std::cout << "Name:" << info.name << std::endl;
        if ( info.probed == false )
            std::cout << "Probe Status = UNsuccessful\n";
        else {
            std::cout << "Probe Status = Successful\n";
            std::cout << "Output Channels = " << info.outputChannels << '\n';
            std::cout << "Input Channels = " << info.inputChannels << '\n';
            std::cout << "Duplex Channels = " << info.duplexChannels << '\n';
            if ( info.isDefaultOutput ) {
                std::cout << "This is the default output device.\n";
            } else {
                std::cout << "This is NOT the default output device.\n";
            }
            if ( info.isDefaultInput ) { std::cout << "This is the default input device.\n";
            } else {
                std::cout << "This is NOT the default input device.\n";
            }
            if ( info.nativeFormats == 0 ) {
                std::cout << "No natively supported data formats(?)!";
            } else {
                std::cout << "Natively supported data formats:\n";
                if ( info.nativeFormats & RTAUDIO_SINT8 )
                    std::cout << "  8-bit int\n";
                if ( info.nativeFormats & RTAUDIO_SINT16 )
                    std::cout << "  16-bit int\n";
                if ( info.nativeFormats & RTAUDIO_SINT24 )
                    std::cout << "  24-bit int\n";
                if ( info.nativeFormats & RTAUDIO_SINT32 )
                    std::cout << "  32-bit int\n";
                if ( info.nativeFormats & RTAUDIO_FLOAT32 )
                    std::cout << "  32-bit float\n";
                if ( info.nativeFormats & RTAUDIO_FLOAT64 )
                    std::cout << "  64-bit float\n";
            }
            if ( info.sampleRates.size() < 1 ) {
                std::cout << "No supported sample rates found!";
            } else {
                std::cout << "Supported sample rates = ";
                for (unsigned int j=0; j<info.sampleRates.size(); j++)
                    std::cout << info.sampleRates[j] << " ";
            }
            std::cout << std::endl;
        }
    }
}

int main(int argc, char *argv[])
{
  int buffer_size, fs, device = 0;
  RtAudio *audio;
  double *data;
  char input;

  // minimal command-line checking
  if (argc != 3 && argc != 4 ) usage();

  chans = (int) atoi(argv[1]);
  fs = (int) atoi(argv[2]);
  if ( argc == 4 )
    device = (int) atoi(argv[3]);

  // Open the realtime output device
  buffer_size = 1024;
  try {
    audio = new RtAudio(device, chans, 0, 0,
                        FORMAT, fs, &buffer_size, 4);
  }
  catch (RtError &error) {
    error.printMessage();
    exit(EXIT_FAILURE);
  }

  data = (double *) calloc(chans, sizeof(double));

  try {
    audio->setStreamCallback(&saw, (void *)data);
    audio->startStream();
  }
  catch (RtError &error) {
    error.printMessage();
    goto cleanup;
  }

  std::cout << "\nPlaying ... press <enter> to quit (buffer size = " << buffer_size << ").\n";
  std::cin.get(input);

  // Stop the stream.
  try {
    audio->stopStream();
  }
  catch (RtError &error) {
    error.printMessage();
  }

 cleanup:
  audio->closeStream();
  delete audio;
  if (data) free(data);

  return 0;
}