comparison core/RTAudio.cpp @ 301:e4392164b458 prerelease

RENAMED BeagleRT to Bela AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, scripts probably not working

 #include <native/task.h>
 #include <native/timer.h>
 #include <native/intr.h>
 #include <rtdk.h>
 
-#include "../include/BeagleRT.h"
+#include "../include/Bela.h"
 #include "../include/PRU.h"
 #include "../include/I2c_Codec.h"
 #include "../include/GPIOcontrol.h"
 
 // ARM interrupt number for PRU event EVTOUT7

 int gRTAudioVerbose = 0;   						// Verbosity level for debugging
 int gAmplifierMutePin = -1;
 int gAmplifierShouldBeginMuted = 0;
 
 // Context which holds all the audio/sensor data passed to the render routines
-BeagleRTContext gContext;
+BelaContext gContext;
 
 // User data passed in from main()
 void *gUserData;
 
 // initAudio() prepares the infrastructure for running PRU-based real-time

 // userData is an opaque pointer which will be passed through to the setup()
 // function for application-specific use
 //
 // Returns 0 on success.
 
-int BeagleRT_initAudio(BeagleRTInitSettings *settings, void *userData)
+int Bela_initAudio(BelaInitSettings *settings, void *userData)
 {
 	// Sanity checks
 	if(settings->pruNumber < 0 || settings->pruNumber > 1) {
 		cout << "Invalid PRU number " << settings->pruNumber << endl;
 		return -1;

 		return -1;
 	}
 	
 	rt_print_auto_init(1);
 
-	BeagleRT_setVerboseLevel(settings->verbose);
+	Bela_setVerboseLevel(settings->verbose);
 	strncpy(gPRUFilename, settings->pruFilename, MAX_PRU_FILENAME_LENGTH);
 	gUserData = userData;
 
 	// Initialise context data structure
-	memset(&gContext, 0, sizeof(BeagleRTContext));
+	memset(&gContext, 0, sizeof(BelaContext));
 
 	if(gRTAudioVerbose) {
 		cout << "Starting with period size " << settings->periodSize << "; ";
 		if(settings->useAnalog)
 			cout << "analog enabled\n";

 		cout << "Error: unable to initialise audio codec\n";
 		return 1;
 	}
 
 	// Set default volume levels
-	BeagleRT_setDACLevel(settings->dacLevel);
-	BeagleRT_setADCLevel(settings->adcLevel);
+	Bela_setDACLevel(settings->dacLevel);
+	Bela_setADCLevel(settings->adcLevel);
 	// TODO: add more argument checks
 	for(int n = 0; n < 2; n++){
 		if(settings->pgaGain[n] > 59.5){
 			std::cerr << "PGA gain out of range [0,59.5]\n";
 			exit(1);
 		}
-		BeagleRT_setPgaGain(settings->pgaGain[n], n);
-	}
-	BeagleRT_setHeadphoneLevel(settings->headphoneLevel);
+		Bela_setPgaGain(settings->pgaGain[n], n);
+	}
+	Bela_setHeadphoneLevel(settings->headphoneLevel);
 
 	// Call the user-defined initialisation function
 	if(!setup(&gContext, userData)) {
 		cout << "Couldn't initialise audio rendering\n";
 		return 1;

 		else {
 			// All systems go. Run the loop; it will end when gShouldStop is set to 1
 
 			if(!gAmplifierShouldBeginMuted) {
 				// First unmute the amplifier
-				if(BeagleRT_muteSpeakers(0)) {
+				if(Bela_muteSpeakers(0)) {
 					if(gRTAudioVerbose)
 						rt_printf("Warning: couldn't set value (high) on amplifier mute pin\n");
 				}
 			}
 

 
 // Create a calculation loop which can run independently of the audio, at a different
 // (equal or lower) priority. Audio priority is defined in BEAGLERT_AUDIO_PRIORITY;
 // priority should be generally be less than this.
 // Returns an (opaque) pointer to the created task on success; 0 on failure
-AuxiliaryTask BeagleRT_createAuxiliaryTask(void (*functionToCall)(void* args), int priority, const char *name, void* args, bool autoSchedule)
+AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void* args), int priority, const char *name, void* args, bool autoSchedule)
 {
 	InternalAuxiliaryTask *newTask = (InternalAuxiliaryTask*)malloc(sizeof(InternalAuxiliaryTask));
 
 	// Attempt to create the task
 	if(rt_task_create(&(newTask->task), name, 0, priority, T_JOINABLE | T_FPU)) {

     
 	getAuxTasks().push_back(newTask);
 
 	return (AuxiliaryTask)newTask;
 }
-AuxiliaryTask BeagleRT_createAuxiliaryTask(void (*functionToCall)(void), int priority, const char *name, bool autoSchedule)
+AuxiliaryTask Bela_createAuxiliaryTask(void (*functionToCall)(void), int priority, const char *name, bool autoSchedule)
 {
         InternalAuxiliaryTask *newTask = (InternalAuxiliaryTask*)malloc(sizeof(InternalAuxiliaryTask));
         
         // Attempt to create the task
         if(rt_task_create(&(newTask->task), name, 0, priority, T_JOINABLE | T_FPU)) {

         return (AuxiliaryTask)newTask;
 }
 
 // Schedule a previously created (and started) auxiliary task. It will run when the priority rules next
 // allow it to be scheduled.
-void BeagleRT_scheduleAuxiliaryTask(AuxiliaryTask task)
+void Bela_scheduleAuxiliaryTask(AuxiliaryTask task)
 {
 	InternalAuxiliaryTask *taskToSchedule = (InternalAuxiliaryTask *)task;
 	if(taskToSchedule->started == false){ // Note: this is not the safest method to check if a task
-		BeagleRT_startAuxiliaryTask(task); // is started (or ready to be resumed), but it probably is the fastest.
+		Bela_startAuxiliaryTask(task); // is started (or ready to be resumed), but it probably is the fastest.
                                            // A safer approach would use rt_task_inquire()
 	}
 	rt_task_resume(&taskToSchedule->task);
 }
-void BeagleRT_autoScheduleAuxiliaryTasks(){
+void Bela_autoScheduleAuxiliaryTasks(){
     vector<InternalAuxiliaryTask*>::iterator it;
 	for(it = getAuxTasks().begin(); it != getAuxTasks().end(); it++) {
 	    if ((InternalAuxiliaryTask *)(*it)->autoSchedule){
-    		BeagleRT_scheduleAuxiliaryTask(*it);
+    		Bela_scheduleAuxiliaryTask(*it);
 	    }
 	}
 }
 
 // Calculation loop that can be used for other tasks running at a lower

 	if(gRTAudioVerbose == 1)
 		rt_printf("auxiliary task %s ended\n", name);
 }
 
 
-int BeagleRT_startAuxiliaryTask(AuxiliaryTask task){
+int Bela_startAuxiliaryTask(AuxiliaryTask task){
 	InternalAuxiliaryTask *taskStruct;
 	taskStruct = (InternalAuxiliaryTask *)task;
 	if(taskStruct->started == true)
 		return 0;
 	if(rt_task_start(&(taskStruct->task), &auxiliaryTaskLoop, taskStruct)) {

 
 // startAudio() should be called only after initAudio() successfully completes.
 // It launches the real-time Xenomai task which runs the audio loop. Returns 0
 // on success.
 
-int BeagleRT_startAudio()
+int Bela_startAudio()
 {
 	// Create audio thread with high Xenomai priority
 	if(rt_task_create(&gRTAudioThread, gRTAudioThreadName, 0, BEAGLERT_AUDIO_PRIORITY, T_JOINABLE | T_FPU)) {
 		  cout << "Error: unable to create Xenomai audio thread" << endl;
 		  return -1;

 	}
 
 	// The user may have created other tasks. Start those also.
 	vector<InternalAuxiliaryTask*>::iterator it;
 	for(it = getAuxTasks().begin(); it != getAuxTasks().end(); it++) {
-		int ret = BeagleRT_startAuxiliaryTask(*it);
+		int ret = Bela_startAuxiliaryTask(*it);
 		if(ret != 0)
 			return -2;
 	}
 	return 0;
 }
 
 // Stop the PRU-based audio from running and wait
 // for the tasks to complete before returning.
 
-void BeagleRT_stopAudio()
+void Bela_stopAudio()
 {
 	// Tell audio thread to stop (if this hasn't been done already)
 	gShouldStop = true;
 
 	if(gRTAudioVerbose)

 		rt_task_join(&(taskStruct->task));
 	}
 }
 
 // Free any resources associated with PRU real-time audio
-void BeagleRT_cleanupAudio()
+void Bela_cleanupAudio()
 {
 	cleanup(&gContext, gUserData);
 
 	// Clean up the auxiliary tasks
 	vector<InternalAuxiliaryTask*>::iterator it;

 	gAmplifierMutePin = -1;
 }
 
 // Set the level of the DAC; affects all outputs (headphone, line, speaker)
 // 0dB is the maximum, -63.5dB is the minimum; 0.5dB steps
-int BeagleRT_setDACLevel(float decibels)
+int Bela_setDACLevel(float decibels)
 {
 	if(gAudioCodec == 0)
 		return -1;
 	return gAudioCodec->setDACVolume((int)floorf(decibels * 2.0 + 0.5));
 }
 
 // Set the level of the ADC
 // 0dB is the maximum, -12dB is the minimum; 1.5dB steps
-int BeagleRT_setADCLevel(float decibels)
+int Bela_setADCLevel(float decibels)
 {
 	if(gAudioCodec == 0)
 		return -1;
 	return gAudioCodec->setADCVolume((int)floorf(decibels * 2.0 + 0.5));
 }
 
 // Set the level of the Programmable Gain Amplifier
 // 59.5dB is maximum, 0dB is minimum; 0.5dB steps
-int BeagleRT_setPgaGain(float decibels, int channel){
+int Bela_setPgaGain(float decibels, int channel){
 	if(gAudioCodec == 0)
 		return -1;
 	return gAudioCodec->setPga(decibels, channel);
 }
 
 // Set the level of the onboard headphone amplifier; affects headphone
 // output only (not line out or speaker)
 // 0dB is the maximum, -63.5dB is the minimum; 0.5dB steps
-int BeagleRT_setHeadphoneLevel(float decibels)
+int Bela_setHeadphoneLevel(float decibels)
 {
 	if(gAudioCodec == 0)
 		return -1;
 	return gAudioCodec->setHPVolume((int)floorf(decibels * 2.0 + 0.5));
 }
 
 // Mute or unmute the onboard speaker amplifiers
 // mute == 0 means unmute; otherwise mute
 // Returns 0 on success
-int BeagleRT_muteSpeakers(int mute)
+int Bela_muteSpeakers(int mute)
 {
 	int pinValue = mute ? LOW : HIGH;
 
 	// Check that we have an enabled pin for controlling the mute
 	if(gAmplifierMutePin < 0)

 
 	return gpio_set_value(gAmplifierMutePin, pinValue);
 }
 
 // Set the verbosity level
-void BeagleRT_setVerboseLevel(int level)
+void Bela_setVerboseLevel(int level)
 {
 	gRTAudioVerbose = level;
 }