ben.carrasco/freeswitch
1
0 Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2026-10-29 06:34:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

update

Browse Source 
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@418 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Anthony Minessale committed 2006-01-20 02:02:03 +00:00
1 parent 1e04eb13b5
commit 0ea203849f
43 files changed
+3940 -4103
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/mod/endpoints/mod_portaudio/mod_portaudio.c
+233 -250
View File
@@ -81,55 +81,51 @@ static struct {
struct private_object {
unsigned int flags;
switch_codec read_codec;
switch_codec write_codec;
switch_codec write_codec;
struct switch_frame read_frame;
unsigned char databuf[SWITCH_RECCOMMENDED_BUFFER_SIZE];
switch_core_session *session;
switch_caller_profile *caller_profile;
switch_caller_profile *caller_profile;
char call_id[50];
PaError err;
PABLIO_Stream *audio_in;
PABLIO_Stream *audio_out;
PABLIO_Stream *audio_in;
PABLIO_Stream *audio_out;
int indev;
int outdev;
};
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_dialplan, globals.dialplan)
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_cid_name, globals.cid_name)
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_cid_num, globals.cid_num)
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_cid_name, globals.cid_name)
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_cid_num, globals.cid_num)
static const switch_endpoint_interface channel_endpoint_interface;
static const switch_endpoint_interface channel_endpoint_interface;
static switch_status channel_on_init(switch_core_session *session);
static switch_status channel_on_hangup(switch_core_session *session);
static switch_status channel_on_ring(switch_core_session *session);
static switch_status channel_on_loopback(switch_core_session *session);
static switch_status channel_on_transmit(switch_core_session *session);
static switch_status channel_outgoing_channel(switch_core_session *session,
switch_caller_profile *outbound_profile,
switch_core_session **new_session);
static switch_status channel_read_frame(switch_core_session *session, switch_frame **frame, int timeout,
switch_io_flag flags, int stream_id);
static switch_status channel_write_frame(switch_core_session *session, switch_frame *frame, int timeout,
switch_io_flag flags, int stream_id);
static switch_status channel_kill_channel(switch_core_session *session, int sig);
static switch_status engage_device(struct private_object *tech_pvt);
static int dump_info(void);
static switch_status load_config(void);
static int get_dev_by_name(char *name, int in);
static switch_status place_call(char *dest, char *out, size_t outlen);
static switch_status hup_call(char *callid, char *out, size_t outlen);
static switch_status call_info(char *callid, char *out, size_t outlen);
static switch_status send_dtmf(char *callid, char *out, size_t outlen);
static switch_status answer_call(char *callid, char *out, size_t outlen);
static switch_status channel_on_init(switch_core_session *session);
static switch_status channel_on_hangup(switch_core_session *session);
static switch_status channel_on_ring(switch_core_session *session);
static switch_status channel_on_loopback(switch_core_session *session);
static switch_status channel_on_transmit(switch_core_session *session);
static switch_status channel_outgoing_channel(switch_core_session *session, switch_caller_profile *outbound_profile, switch_core_session **new_session);
static switch_status channel_read_frame(switch_core_session *session, switch_frame **frame, int timeout, switch_io_flag flags, int stream_id);
static switch_status channel_write_frame(switch_core_session *session, switch_frame *frame, int timeout, switch_io_flag flags, int stream_id);
static switch_status channel_kill_channel(switch_core_session *session, int sig);
static switch_status engage_device(struct private_object *tech_pvt);
static int dump_info(void);
static switch_status load_config(void);
static int get_dev_by_name(char *name, int in);
static switch_status place_call(char *dest, char *out, size_t outlen);
static switch_status hup_call(char *callid, char *out, size_t outlen);
static switch_status call_info(char *callid, char *out, size_t outlen);
static switch_status send_dtmf(char *callid, char *out, size_t outlen);
static switch_status answer_call(char *callid, char *out, size_t outlen);
/*
State methods they get called when the state changes to the specific state
returning SWITCH_STATUS_SUCCESS tells the core to execute the standard state method next
so if you fully implement the state you can return SWITCH_STATUS_FALSE to skip it.
*/
static switch_status channel_on_init(switch_core_session *session)
static switch_status channel_on_init(switch_core_session *session)
{
switch_channel *channel;
struct private_object *tech_pvt = NULL;
@@ -144,7 +140,7 @@ SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_dialplan, globals.dialplan)
tech_pvt->read_frame.buflen = sizeof(tech_pvt->databuf);
switch_set_flag(tech_pvt, TFLAG_IO);
/* Move Channel's State Machine to RING */
switch_channel_set_state(channel, CS_RING);
@@ -178,7 +174,7 @@ static switch_status channel_on_execute(switch_core_session *session)
tech_pvt = switch_core_session_get_private(session);
assert(tech_pvt != NULL);
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s CHANNEL EXECUTE\n", switch_channel_get_name(channel));
@@ -227,7 +223,7 @@ static switch_status channel_kill_channel(switch_core_session *session, int sig)
{
switch_channel *channel = NULL;
struct private_object *tech_pvt = NULL;
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
@@ -240,7 +236,7 @@ static switch_status channel_kill_channel(switch_core_session *session, int sig)
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s CHANNEL KILL\n", switch_channel_get_name(channel));
return SWITCH_STATUS_SUCCESS;
}
@@ -268,25 +264,25 @@ static switch_status channel_on_transmit(switch_core_session *session)
/* Turn on the device */
engage_device(tech_pvt);
while (switch_channel_get_state(channel) == CS_TRANSMIT && !switch_test_flag(tech_pvt, TFLAG_ANSWER)) {
while(switch_channel_get_state(channel) == CS_TRANSMIT && !switch_test_flag(tech_pvt, TFLAG_ANSWER)) {
if (switch_time_now() - last >= waitsec) {
char buf[512];
switch_event *event;
char buf[512];
switch_event *event;
snprintf(buf, sizeof(buf), "BRRRRING! BRRRRING! call %s\n", tech_pvt->call_id);
snprintf(buf, sizeof(buf), "BRRRRING! BRRRRING! call %s\n", tech_pvt->call_id);
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, MY_EVENT_RINGING) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_info", buf);
switch_event_fire(&event);
}
if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, MY_EVENT_RINGING) == SWITCH_STATUS_SUCCESS) {
switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_info", buf);
switch_event_fire(&event);
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s\n", buf);
last = switch_time_now();
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "%s\n", buf);
last = switch_time_now();
}
switch_yield(50000);
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "CHANNEL TRANSMIT\n");
@@ -297,8 +293,7 @@ static switch_status channel_on_transmit(switch_core_session *session)
/* Make sure when you have 2 sessions in the same scope that you pass the appropriate one to the routines
that allocate memory or you will have 1 channel with memory allocated from another channel's pool!
*/
static switch_status channel_outgoing_channel(switch_core_session *session, switch_caller_profile *outbound_profile,
switch_core_session **new_session)
static switch_status channel_outgoing_channel(switch_core_session *session, switch_caller_profile *outbound_profile, switch_core_session **new_session)
{
if ((*new_session = switch_core_session_request(&channel_endpoint_interface, NULL))) {
struct private_object *tech_pvt;
@@ -306,8 +301,7 @@ static switch_status channel_outgoing_channel(switch_core_session *session, swit
switch_caller_profile *caller_profile;
switch_core_session_add_stream(*new_session, NULL);
if ((tech_pvt =
(struct private_object *) switch_core_session_alloc(*new_session, sizeof(struct private_object)))) {
if ((tech_pvt = (struct private_object *) switch_core_session_alloc(*new_session, sizeof(struct private_object)))) {
memset(tech_pvt, 0, sizeof(*tech_pvt));
channel = switch_core_session_get_channel(*new_session);
switch_core_session_set_private(*new_session, tech_pvt);
@@ -323,9 +317,7 @@ static switch_status channel_outgoing_channel(switch_core_session *session, swit
caller_profile = switch_caller_profile_clone(*new_session, outbound_profile);
switch_channel_set_caller_profile(channel, caller_profile);
tech_pvt->caller_profile = caller_profile;
snprintf(name, sizeof(name), "PortAudio/%s-%04x",
caller_profile->destination_number ? caller_profile->destination_number : modname,
rand() & 0xffff);
snprintf(name, sizeof(name), "PortAudio/%s-%04x", caller_profile->destination_number ? caller_profile->destination_number : modname, rand() & 0xffff);
switch_channel_set_name(channel, name);
} else {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Doh! no caller profile\n");
@@ -373,11 +365,10 @@ static switch_status channel_send_dtmf(switch_core_session *session, char *dtmf)
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "DTMF ON CALL %s [%s]\n", tech_pvt->call_id, dtmf);
return SWITCH_STATUS_SUCCESS;
return SWITCH_STATUS_SUCCESS;
}
static switch_status channel_read_frame(switch_core_session *session, switch_frame **frame, int timeout,
switch_io_flag flags, int stream_id)
static switch_status channel_read_frame(switch_core_session *session, switch_frame **frame, int timeout, switch_io_flag flags, int stream_id)
{
switch_channel *channel = NULL;
struct private_object *tech_pvt = NULL;
@@ -394,12 +385,10 @@ static switch_status channel_read_frame(switch_core_session *session, switch_fra
return SWITCH_STATUS_FALSE;
}
switch_mutex_lock(globals.device_lock);
if (tech_pvt->audio_in &&
(samples =
ReadAudioStream(tech_pvt->audio_in, tech_pvt->read_frame.data,
tech_pvt->read_codec.implementation->samples_per_frame))) {
if (tech_pvt->audio_in &&
(samples = ReadAudioStream(tech_pvt->audio_in, tech_pvt->read_frame.data, tech_pvt->read_codec.implementation->samples_per_frame))) {
tech_pvt->read_frame.datalen = samples * 2;
tech_pvt->read_frame.samples = samples;
*frame = &tech_pvt->read_frame;
@@ -410,8 +399,7 @@ static switch_status channel_read_frame(switch_core_session *session, switch_fra
return status;
}
static switch_status channel_write_frame(switch_core_session *session, switch_frame *frame, int timeout,
switch_io_flag flags, int stream_id)
static switch_status channel_write_frame(switch_core_session *session, switch_frame *frame, int timeout, switch_io_flag flags, int stream_id)
{
switch_channel *channel = NULL;
struct private_object *tech_pvt = NULL;
@@ -422,18 +410,19 @@ static switch_status channel_write_frame(switch_core_session *session, switch_fr
tech_pvt = switch_core_session_get_private(session);
assert(tech_pvt != NULL);
if (!switch_test_flag(tech_pvt, TFLAG_IO)) {
if(!switch_test_flag(tech_pvt, TFLAG_IO)) {
return SWITCH_STATUS_FALSE;
}
//switch_mutex_lock(globals.device_lock);
if (tech_pvt->audio_out) {
WriteAudioStream(tech_pvt->audio_out, (short *) frame->data, (int) (frame->datalen / sizeof(SAMPLE)));
WriteAudioStream(tech_pvt->audio_out, (short *)frame->data, (int)(frame->datalen / sizeof(SAMPLE)));
status = SWITCH_STATUS_SUCCESS;
}
//switch_mutex_unlock(globals.device_lock);
return status;
}
static switch_status channel_answer_channel(switch_core_session *session)
@@ -452,83 +441,82 @@ static switch_status channel_answer_channel(switch_core_session *session)
static struct switch_api_interface send_dtmf_interface = {
/*.interface_name */ "padtmf",
/*.desc */ "PortAudio Dial DTMF",
/*.function */ send_dtmf,
/*.next */ NULL
/*.interface_name*/ "padtmf",
/*.desc*/ "PortAudio Dial DTMF",
/*.function*/ send_dtmf,
/*.next*/ NULL
};
static struct switch_api_interface answer_call_interface = {
/*.interface_name */ "paoffhook",
/*.desc */ "PortAudio Answer Call",
/*.function */ answer_call,
/*.next */ &send_dtmf_interface
/*.interface_name*/ "paoffhook",
/*.desc*/ "PortAudio Answer Call",
/*.function*/ answer_call,
/*.next*/ &send_dtmf_interface
};
static struct switch_api_interface channel_info_interface = {
/*.interface_name */ "painfo",
/*.desc */ "PortAudio Call Info",
/*.function */ call_info,
/*.next */ &answer_call_interface
/*.interface_name*/ "painfo",
/*.desc*/ "PortAudio Call Info",
/*.function*/ call_info,
/*.next*/ &answer_call_interface
};
static struct switch_api_interface channel_hup_interface = {
/*.interface_name */ "pahup",
/*.desc */ "PortAudio Hangup Call",
/*.function */ hup_call,
/*.next */ &channel_info_interface
/*.interface_name*/ "pahup",
/*.desc*/ "PortAudio Hangup Call",
/*.function*/ hup_call,
/*.next*/ &channel_info_interface
};
static struct switch_api_interface channel_api_interface = {
/*.interface_name */ "pacall",
/*.desc */ "PortAudio Call",
/*.function */ place_call,
/*.next */ &channel_hup_interface
/*.interface_name*/ "pacall",
/*.desc*/ "PortAudio Call",
/*.function*/ place_call,
/*.next*/ &channel_hup_interface
};
static const switch_event_handler_table channel_event_handlers = {
/*.on_init */ channel_on_init,
/*.on_ring */ channel_on_ring,
/*.on_execute */ channel_on_execute,
/*.on_hangup */ channel_on_hangup,
/*.on_loopback */ channel_on_loopback,
/*.on_transmit */ channel_on_transmit
/*.on_init*/ channel_on_init,
/*.on_ring*/ channel_on_ring,
/*.on_execute*/ channel_on_execute,
/*.on_hangup*/ channel_on_hangup,
/*.on_loopback*/ channel_on_loopback,
/*.on_transmit*/ channel_on_transmit
};
static const switch_io_routines channel_io_routines = {
/*.outgoing_channel */ channel_outgoing_channel,
/*.answer_channel */ channel_answer_channel,
/*.read_frame */ channel_read_frame,
/*.write_frame */ channel_write_frame,
/*.kill_channel */ channel_kill_channel,
/*.waitfor_read */ channel_waitfor_read,
/*.waitfor_write */ channel_waitfor_write,
/*.send_dtmf */ channel_send_dtmf
/*.outgoing_channel*/ channel_outgoing_channel,
/*.answer_channel*/ channel_answer_channel,
/*.read_frame*/ channel_read_frame,
/*.write_frame*/ channel_write_frame,
/*.kill_channel*/ channel_kill_channel,
/*.waitfor_read*/ channel_waitfor_read,
/*.waitfor_write*/ channel_waitfor_write,
/*.send_dtmf*/ channel_send_dtmf
};
static const switch_endpoint_interface channel_endpoint_interface = {
/*.interface_name */ "portaudio",
/*.io_routines */ &channel_io_routines,
/*.event_handlers */ &channel_event_handlers,
/*.private */ NULL,
/*.next */ NULL
/*.interface_name*/ "portaudio",
/*.io_routines*/ &channel_io_routines,
/*.event_handlers*/ &channel_event_handlers,
/*.private*/ NULL,
/*.next*/ NULL
};
static const switch_loadable_module_interface channel_module_interface = {
/*.module_name */ modname,
/*.endpoint_interface */ &channel_endpoint_interface,
/*.timer_interface */ NULL,
/*.dialplan_interface */ NULL,
/*.codec_interface */ NULL,
/*.application_interface */ NULL,
/*.api_interface */ &channel_api_interface
/*.module_name*/ modname,
/*.endpoint_interface*/ &channel_endpoint_interface,
/*.timer_interface*/ NULL,
/*.dialplan_interface*/ NULL,
/*.codec_interface*/ NULL,
/*.application_interface*/ NULL,
/*.api_interface*/ &channel_api_interface
};
SWITCH_MOD_DECLARE(switch_status) switch_module_load(const switch_loadable_module_interface **interface, char *filename)
{
SWITCH_MOD_DECLARE(switch_status) switch_module_load(const switch_loadable_module_interface **interface, char *filename) {
if (switch_core_new_memory_pool(&module_pool) != SWITCH_STATUS_SUCCESS) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "OH OH no pool\n");
@@ -540,7 +528,7 @@ SWITCH_MOD_DECLARE(switch_status) switch_module_load(const switch_loadable_modul
load_config();
switch_core_hash_init(&globals.call_hash, module_pool);
switch_mutex_init(&globals.device_lock, SWITCH_MUTEX_NESTED, module_pool);
dump_info();
if (switch_event_reserve_subclass(MY_EVENT_RINGING) != SWITCH_STATUS_SUCCESS) {
@@ -561,14 +549,14 @@ static switch_status load_config(void)
switch_config cfg;
char *var, *val;
char *cf = "portaudio.conf";
memset(&globals, 0, sizeof(globals));
if (!switch_config_open_file(&cfg, cf)) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "open of %s failed\n", cf);
return SWITCH_STATUS_TERM;
}
while (switch_config_next_pair(&cfg, &var, &val)) {
if (!strcasecmp(cfg.category, "settings")) {
if (!strcmp(var, "debug")) {
@@ -583,13 +571,13 @@ static switch_status load_config(void)
set_global_cid_num(val);
} else if (!strcmp(var, "indev")) {
if (*val == '#') {
globals.indev = atoi(val + 1);
globals.indev = atoi(val+1);
} else {
globals.indev = get_dev_by_name(val, 1);
}
} else if (!strcmp(var, "outdev")) {
if (*val == '#') {
globals.outdev = atoi(val + 1);
globals.outdev = atoi(val+1);
} else {
globals.outdev = get_dev_by_name(val, 0);
}
@@ -600,13 +588,13 @@ static switch_status load_config(void)
if (!globals.dialplan) {
set_global_dialplan("default");
}
if (!globals.sample_rate) {
globals.sample_rate = 8000;
}
switch_config_close_file(&cfg);
return SWITCH_STATUS_SUCCESS;
}
@@ -622,28 +610,28 @@ SWITCH_MOD_DECLARE(switch_status) switch_module_runtime(void)
SWITCH_MOD_DECLARE(switch_status) switch_module_shutdown(void)
{
Pa_Terminate();
Pa_Terminate();
return SWITCH_STATUS_SUCCESS;
}
static int get_dev_by_name(char *name, int in)
{
int i;
int numDevices;
const PaDeviceInfo *pdi;
numDevices = Pa_CountDevices();
int i;
int numDevices;
const PaDeviceInfo *pdi;
numDevices = Pa_CountDevices();
if (numDevices < 0) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "ERROR: Pa_CountDevices returned 0x%x\n", numDevices);
return -2;
}
for (i = 0; i < numDevices; i++) {
pdi = Pa_GetDeviceInfo(i);
if (strstr(pdi->name, name)) {
if (in && pdi->maxInputChannels) {
if( numDevices < 0 ) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "ERROR: Pa_CountDevices returned 0x%x\n", numDevices );
return -2;
}
for( i=0; i<numDevices; i++ ) {
pdi = Pa_GetDeviceInfo( i );
if(strstr(pdi->name, name)) {
if(in && pdi->maxInputChannels) {
return i;
} else if (!in && pdi->maxOutputChannels) {
return i;
@@ -656,62 +644,58 @@ static int get_dev_by_name(char *name, int in)
static int dump_info(void)
{
int i, j;
int numDevices;
const PaDeviceInfo *pdi;
PaError err;
numDevices = Pa_CountDevices();
if (numDevices < 0) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "ERROR: Pa_CountDevices returned 0x%x\n", numDevices);
err = numDevices;
goto error;
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Number of devices = %d\n", numDevices);
for (i = 0; i < numDevices; i++) {
pdi = Pa_GetDeviceInfo(i);
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "---------------------------------------------- #%d", i);
if (i == Pa_GetDefaultInputDeviceID())
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, " DefaultInput");
if (i == Pa_GetDefaultOutputDeviceID())
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, " DefaultOutput");
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "\nName = %s\n", pdi->name);
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Max Inputs = %d", pdi->maxInputChannels);
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, ", Max Outputs = %d\n", pdi->maxOutputChannels);
if (pdi->numSampleRates == -1) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Sample Rate Range = %f to %f\n", pdi->sampleRates[0],
pdi->sampleRates[1]);
} else {
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Sample Rates =");
for (j = 0; j < pdi->numSampleRates; j++) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, " %8.2f,", pdi->sampleRates[j]);
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "\n");
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Native Sample Formats = ");
if (pdi->nativeSampleFormats & paInt8)
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt8, ");
if (pdi->nativeSampleFormats & paUInt8)
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paUInt8, ");
if (pdi->nativeSampleFormats & paInt16)
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt16, ");
if (pdi->nativeSampleFormats & paInt32)
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt32, ");
if (pdi->nativeSampleFormats & paFloat32)
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paFloat32, ");
if (pdi->nativeSampleFormats & paInt24)
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt24, ");
if (pdi->nativeSampleFormats & paPackedInt24)
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paPackedInt24, ");
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "\n");
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "----------------------------------------------\n");
return 0;
error:
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "An error occured while using the portaudio stream\n");
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Error number: %d\n", err);
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Error message: %s\n", Pa_GetErrorText(err));
return err;
int i,j;
int numDevices;
const PaDeviceInfo *pdi;
PaError err;
numDevices = Pa_CountDevices();
if( numDevices < 0 )
{
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "ERROR: Pa_CountDevices returned 0x%x\n", numDevices );
err = numDevices;
goto error;
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Number of devices = %d\n", numDevices );
for( i=0; i<numDevices; i++ )
{
pdi = Pa_GetDeviceInfo( i );
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "---------------------------------------------- #%d", i );
if( i == Pa_GetDefaultInputDeviceID() ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, " DefaultInput");
if( i == Pa_GetDefaultOutputDeviceID() ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, " DefaultOutput");
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "\nName = %s\n", pdi->name );
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Max Inputs = %d", pdi->maxInputChannels );
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, ", Max Outputs = %d\n", pdi->maxOutputChannels );
if( pdi->numSampleRates == -1 )
{
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Sample Rate Range = %f to %f\n", pdi->sampleRates[0], pdi->sampleRates[1] );
}
else
{
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Sample Rates =");
for( j=0; j<pdi->numSampleRates; j++ )
{
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, " %8.2f,", pdi->sampleRates[j] );
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "\n");
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Native Sample Formats = ");
if( pdi->nativeSampleFormats & paInt8 ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt8, ");
if( pdi->nativeSampleFormats & paUInt8 ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paUInt8, ");
if( pdi->nativeSampleFormats & paInt16 ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt16, ");
if( pdi->nativeSampleFormats & paInt32 ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt32, ");
if( pdi->nativeSampleFormats & paFloat32 ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paFloat32, ");
if( pdi->nativeSampleFormats & paInt24 ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paInt24, ");
if( pdi->nativeSampleFormats & paPackedInt24 ) switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "paPackedInt24, ");
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "\n");
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "----------------------------------------------\n");
return 0;
error:
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "An error occured while using the portaudio stream\n" );
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Error number: %d\n", err );
switch_console_printf(SWITCH_CHANNEL_CONSOLE_CLEAN, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
static switch_status engage_device(struct private_object *tech_pvt)
@@ -729,59 +713,56 @@ static switch_status engage_device(struct private_object *tech_pvt)
codec_ms,
1,
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Can't load codec?\n");
return SWITCH_STATUS_FALSE;
} else {
if (switch_core_codec_init(&tech_pvt->write_codec,
"L16",
sample_rate,
codec_ms,
1,
SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
NULL,
switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Can't load codec?\n");
switch_core_codec_destroy(&tech_pvt->read_codec);
return SWITCH_STATUS_FALSE;
} else {
if (switch_core_codec_init(&tech_pvt->write_codec,
"L16",
sample_rate,
codec_ms,
1,
SWITCH_CODEC_FLAG_ENCODE |SWITCH_CODEC_FLAG_DECODE,
NULL,
switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Can't load codec?\n");
switch_core_codec_destroy(&tech_pvt->read_codec);
return SWITCH_STATUS_FALSE;
}
}
}
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Loaded codec L16 %dhz %dms on %s\n", sample_rate, codec_ms,
switch_channel_get_name(channel));
tech_pvt->read_frame.rate = sample_rate;
tech_pvt->read_frame.codec = &tech_pvt->read_codec;
switch_core_session_set_read_codec(tech_pvt->session, &tech_pvt->read_codec);
switch_core_session_set_write_codec(tech_pvt->session, &tech_pvt->write_codec);
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Loaded codec L16 %dhz %dms on %s\n", sample_rate, codec_ms, switch_channel_get_name(channel));
tech_pvt->read_frame.rate = sample_rate;
tech_pvt->read_frame.codec = &tech_pvt->read_codec;
switch_core_session_set_read_codec(tech_pvt->session, &tech_pvt->read_codec);
switch_core_session_set_write_codec(tech_pvt->session, &tech_pvt->write_codec);
tech_pvt->indev = globals.indev;
tech_pvt->outdev = globals.outdev;
switch_mutex_lock(globals.device_lock);
if ((tech_pvt->err =
OpenAudioStream(&tech_pvt->audio_in, sample_rate, SAMPLE_TYPE, PABLIO_READ | PABLIO_MONO, tech_pvt->indev,
-1)) == paNoError) {
if ((tech_pvt->err =
OpenAudioStream(&tech_pvt->audio_out, sample_rate, SAMPLE_TYPE, PABLIO_WRITE | PABLIO_MONO, -1,
tech_pvt->outdev)) != paNoError) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Can't open audio out [%d]!\n", tech_pvt->outdev);
CloseAudioStream(tech_pvt->audio_in);
tech_pvt->audio_in = NULL;
tech_pvt->indev = globals.indev;
tech_pvt->outdev = globals.outdev;
switch_mutex_lock(globals.device_lock);
if ((tech_pvt->err = OpenAudioStream( &tech_pvt->audio_in, sample_rate, SAMPLE_TYPE, PABLIO_READ | PABLIO_MONO, tech_pvt->indev, -1)) == paNoError) {
if ((tech_pvt->err = OpenAudioStream(&tech_pvt->audio_out, sample_rate, SAMPLE_TYPE, PABLIO_WRITE | PABLIO_MONO, -1, tech_pvt->outdev)) != paNoError) {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Can't open audio out [%d]!\n", tech_pvt->outdev);
CloseAudioStream(tech_pvt->audio_in);
tech_pvt->audio_in = NULL;
}
} else {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Can't open audio in [%d]!\n", tech_pvt->indev);
}
} else {
switch_console_printf(SWITCH_CHANNEL_CONSOLE, "Can't open audio in [%d]!\n", tech_pvt->indev);
}
switch_mutex_unlock(globals.device_lock);
switch_mutex_unlock(globals.device_lock);
if (tech_pvt->err == paNoError) {
snprintf(tech_pvt->call_id, sizeof(tech_pvt->call_id), "%d", globals.call_id++);
switch_core_hash_insert(globals.call_hash, tech_pvt->call_id, tech_pvt);
return SWITCH_STATUS_SUCCESS;
} else {
switch_core_codec_destroy(&tech_pvt->read_codec);
switch_core_codec_destroy(&tech_pvt->write_codec);
switch_core_session_destroy(&tech_pvt->session);
}
return SWITCH_STATUS_FALSE;
if (tech_pvt->err == paNoError) {
snprintf(tech_pvt->call_id, sizeof(tech_pvt->call_id), "%d", globals.call_id++);
switch_core_hash_insert(globals.call_hash, tech_pvt->call_id, tech_pvt);
return SWITCH_STATUS_SUCCESS;
} else {
switch_core_codec_destroy(&tech_pvt->read_codec);
switch_core_codec_destroy(&tech_pvt->write_codec);
switch_core_session_destroy(&tech_pvt->session);
}
return SWITCH_STATUS_FALSE;
}
static switch_status place_call(char *dest, char *out, size_t outlen)
@@ -815,12 +796,14 @@ static switch_status place_call(char *dest, char *out, size_t outlen)
if ((tech_pvt->caller_profile = switch_caller_profile_new(session,
globals.dialplan,
globals.cid_name,
globals.cid_num, NULL, NULL, NULL, dest))) {
globals.cid_num,
NULL,
NULL,
NULL,
dest))) {
char name[128];
switch_channel_set_caller_profile(channel, tech_pvt->caller_profile);
snprintf(name, sizeof(name), "PortAudio/%s-%04x",
tech_pvt->caller_profile->destination_number ? tech_pvt->caller_profile->
destination_number : modname, rand() & 0xffff);
snprintf(name, sizeof(name), "PortAudio/%s-%04x", tech_pvt->caller_profile->destination_number ? tech_pvt->caller_profile->destination_number : modname, rand() & 0xffff);
switch_channel_set_name(channel, name);
}
tech_pvt->session = session;
@@ -829,7 +812,7 @@ static switch_status place_call(char *dest, char *out, size_t outlen)
switch_core_session_thread_launch(tech_pvt->session);
snprintf(out, outlen, "SUCCESS: %s", tech_pvt->call_id);
}
}
}
return status;
}
@@ -845,7 +828,7 @@ static switch_status hup_call(char *callid, char *out, size_t outlen)
callid = tmp;
}
if (!callid || !strcasecmp(callid, "all")) {
switch_hash_index_t *hi;
switch_hash_index_t* hi;
void *val;
int i = 0;
@@ -862,7 +845,7 @@ static switch_status hup_call(char *callid, char *out, size_t outlen)
return SWITCH_STATUS_SUCCESS;
}
if ((tech_pvt = switch_core_hash_find(globals.call_hash, callid))) {
channel = switch_core_session_get_channel(tech_pvt->session);
@@ -926,7 +909,7 @@ static void print_info(struct private_object *tech_pvt, char *out, size_t outlen
assert(channel != NULL);
snprintf(out, outlen, "CALL %s\t%s\t%s\t%s\t%s\n",
tech_pvt->call_id,
tech_pvt->call_id,
tech_pvt->caller_profile->caller_id_name ? tech_pvt->caller_profile->caller_id_name : "n/a",
tech_pvt->caller_profile->caller_id_number ? tech_pvt->caller_profile->caller_id_number : "n/a",
tech_pvt->caller_profile->destination_number ? tech_pvt->caller_profile->destination_number : "n/a",
@@ -937,19 +920,19 @@ static void print_info(struct private_object *tech_pvt, char *out, size_t outlen
static switch_status call_info(char *callid, char *out, size_t outlen)
{
struct private_object *tech_pvt;
switch_hash_index_t *hi;
switch_hash_index_t* hi;
void *val;
if (!callid || !strcasecmp(callid, "all")) {
for (hi = apr_hash_first(module_pool, globals.call_hash); hi; hi = switch_hash_next(hi)) {
switch_hash_this(hi, NULL, NULL, &val);
tech_pvt = val;
print_info(tech_pvt, out + strlen(out), outlen - strlen(out));
print_info(tech_pvt, out + strlen(out), outlen - strlen(out));
}
} else if ((tech_pvt = switch_core_hash_find(globals.call_hash, callid))) {
print_info(tech_pvt, out, outlen);
} else {
strncpy(out, "NO SUCH CALL", outlen - 1);
}
return SWITCH_STATUS_SUCCESS;
}
src/mod/endpoints/mod_portaudio/pablio.c
+260 -266
View File
@@ -32,12 +32,12 @@
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
*/
/* History:
* PLB021214 - check for valid stream in CloseAudioStream() to prevent hang.
* add timeOutMSec to CloseAudioStream() to prevent hang.
*/
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
@@ -45,155 +45,146 @@
#include "ringbuffer.h"
#include "pablio.h"
#include <string.h>
/************************************************************************/
/******** Constants *****************************************************/
/************************************************************************/
/************************************************************************/
/******** Constants *****************************************************/
/************************************************************************/
#define FRAMES_PER_BUFFER (256)
/************************************************************************/
/******** Prototypes ****************************************************/
/************************************************************************/
␍static int blockingIOCallback(void *inputBuffer, void *outputBuffer, ␍unsigned long framesPerBuffer,
␍PaTimestamp outTime, void *userData);
␍static PaError PABLIO_InitFIFO(RingBuffer * rbuf, long numFrames, long bytesPerFrame);
␍static PaError PABLIO_TermFIFO(RingBuffer * rbuf);
␍
/************************************************************************/
/******** Functions *****************************************************/
/************************************************************************/
/************************************************************************/
/******** Prototypes ****************************************************/
/************************************************************************/
static int blockingIOCallback( void *inputBuffer, void *outputBuffer,
unsigned long framesPerBuffer,
PaTimestamp outTime, void *userData );
static PaError PABLIO_InitFIFO( RingBuffer *rbuf, long numFrames, long bytesPerFrame );
static PaError PABLIO_TermFIFO( RingBuffer *rbuf );
/************************************************************************/
/******** Functions *****************************************************/
/************************************************************************/
/* Called from PortAudio.
* Read and write data only if there is room in FIFOs.
*/
static int blockingIOCallback(void *inputBuffer, void *outputBuffer, ␍unsigned long framesPerBuffer,
␍PaTimestamp outTime, void *userData)
{
␍PABLIO_Stream * data = (PABLIO_Stream *) userData;
␍long numBytes = data->bytesPerFrame * framesPerBuffer;
␍(void) outTime;
␍
/* This may get called with NULL inputBuffer during initial setup. */
if (inputBuffer != NULL)
␍ {
␍RingBuffer_Write(&data->inFIFO, inputBuffer, numBytes);
␍}
␍if (outputBuffer != NULL)
␍ {
␍int i;
␍int numRead = RingBuffer_Read(&data->outFIFO, outputBuffer, numBytes);
/* Zero out remainder of buffer if we run out of data. */
for (i = numRead; i < numBytes; i++)
␍ {
␍((char *) outputBuffer)[i] = 0;
␍} ␍}
␍␍return 0;
␍}
␍
/* Allocate buffer. */
static PaError PABLIO_InitFIFO(RingBuffer * rbuf, long numFrames, long bytesPerFrame)
{
␍long numBytes = numFrames * bytesPerFrame;
␍char *buffer = (char *) malloc(numBytes);
␍if (buffer == NULL)
return paInsufficientMemory;
␍memset(buffer, 0, numBytes);
␍return (PaError) RingBuffer_Init(rbuf, numBytes, buffer);
␍}
␍
/* Free buffer. */
static PaError PABLIO_TermFIFO(RingBuffer * rbuf)
{
␍if (rbuf->buffer)
free(rbuf->buffer);
␍rbuf->buffer = NULL;
␍return paNoError;
␍}
␍
*/
static int blockingIOCallback( void *inputBuffer, void *outputBuffer,
unsigned long framesPerBuffer,
PaTimestamp outTime, void *userData )
{
PABLIO_Stream *data = (PABLIO_Stream*)userData;
long numBytes = data->bytesPerFrame * framesPerBuffer;
(void) outTime;
/* This may get called with NULL inputBuffer during initial setup. */
if( inputBuffer != NULL )
{
RingBuffer_Write( &data->inFIFO, inputBuffer, numBytes );
}
if( outputBuffer != NULL )
{
int i;
int numRead = RingBuffer_Read( &data->outFIFO, outputBuffer, numBytes );
/* Zero out remainder of buffer if we run out of data. */
for( i=numRead; i<numBytes; i++ )
{
((char *)outputBuffer)[i] = 0;
}
}
return 0;
}
/* Allocate buffer. */
static PaError PABLIO_InitFIFO( RingBuffer *rbuf, long numFrames, long bytesPerFrame )
{
long numBytes = numFrames * bytesPerFrame;
char *buffer = (char *) malloc( numBytes );
if( buffer == NULL ) return paInsufficientMemory;
memset( buffer, 0, numBytes );
return (PaError) RingBuffer_Init( rbuf, numBytes, buffer );
}
/* Free buffer. */
static PaError PABLIO_TermFIFO( RingBuffer *rbuf )
{
if( rbuf->buffer ) free( rbuf->buffer );
rbuf->buffer = NULL;
return paNoError;
}
/************************************************************
* Write data to ring buffer.
* Will not return until all the data has been written.
*/
long WriteAudioStream(PABLIO_Stream * aStream, void *data, long numFrames)
{
␍long bytesWritten;
␍char *p = (char *) data;
␍long numBytes = aStream->bytesPerFrame * numFrames;
␍while (numBytes > 0)
␍ {
␍bytesWritten = RingBuffer_Write(&aStream->outFIFO, p, numBytes);
␍numBytes -= bytesWritten;
␍p += bytesWritten;
␍if (numBytes > 0)
Pa_Sleep(10);
␍}
␍return numFrames;
␍}
␍
*/
long WriteAudioStream( PABLIO_Stream *aStream, void *data, long numFrames )
{
long bytesWritten;
char *p = (char *) data;
long numBytes = aStream->bytesPerFrame * numFrames;
while( numBytes > 0)
{
bytesWritten = RingBuffer_Write( &aStream->outFIFO, p, numBytes );
numBytes -= bytesWritten;
p += bytesWritten;
if( numBytes > 0) Pa_Sleep(10);
}
return numFrames;
}
/************************************************************
* Read data from ring buffer.
* Will not return until all the data has been read.
*/
long ReadAudioStream(PABLIO_Stream * aStream, void *data, long numFrames)
{
␍long bytesRead;
␍char *p = (char *) data;
␍long numBytes = aStream->bytesPerFrame * numFrames;
␍while (numBytes > 0)
␍ {
␍bytesRead = RingBuffer_Read(&aStream->inFIFO, p, numBytes);
␍numBytes -= bytesRead;
␍p += bytesRead;
␍if (numBytes > 0)
Pa_Sleep(10);
␍}
␍return numFrames;
␍}
␍
*/
long ReadAudioStream( PABLIO_Stream *aStream, void *data, long numFrames )
{
long bytesRead;
char *p = (char *) data;
long numBytes = aStream->bytesPerFrame * numFrames;
while( numBytes > 0)
{
bytesRead = RingBuffer_Read( &aStream->inFIFO, p, numBytes );
numBytes -= bytesRead;
p += bytesRead;
if( numBytes > 0) Pa_Sleep(10);
}
return numFrames;
}
/************************************************************
* Return the number of frames that could be written to the stream without
* having to wait.
*/
long GetAudioStreamWriteable(PABLIO_Stream * aStream)
{
␍int bytesEmpty = RingBuffer_GetWriteAvailable(&aStream->outFIFO);
␍return bytesEmpty / aStream->bytesPerFrame;
␍}
␍
*/
long GetAudioStreamWriteable( PABLIO_Stream *aStream )
{
int bytesEmpty = RingBuffer_GetWriteAvailable( &aStream->outFIFO );
return bytesEmpty / aStream->bytesPerFrame;
}
/************************************************************
* Return the number of frames that are available to be read from the
* stream without having to wait.
*/
long GetAudioStreamReadable(PABLIO_Stream * aStream)
{
␍int bytesFull = RingBuffer_GetReadAvailable(&aStream->inFIFO);
␍return bytesFull / aStream->bytesPerFrame;
␍}
␍
/************************************************************/
static unsigned long RoundUpToNextPowerOf2(unsigned long n)
{
␍long numBits = 0;
␍if (((n - 1) & n) == 0)
return n; /* Already Power of two. */
␍while (n > 0)
␍ {
␍n = n >> 1;
␍numBits++;
␍}
␍return (1 << numBits);
␍}
␍
*/
long GetAudioStreamReadable( PABLIO_Stream *aStream )
{
int bytesFull = RingBuffer_GetReadAvailable( &aStream->inFIFO );
return bytesFull / aStream->bytesPerFrame;
}
/************************************************************/
static unsigned long RoundUpToNextPowerOf2( unsigned long n )
{
long numBits = 0;
if( ((n-1) & n) == 0) return n; /* Already Power of two. */
while( n > 0 )
{
n= n>>1;
numBits++;
}
return (1<<numBits);
}
/************************************************************
* Opens a PortAudio stream with default characteristics.
* Allocates PABLIO_Stream structure.
@@ -201,133 +192,136 @@ static unsigned long RoundUpToNextPowerOf2(unsigned long n)
* flags parameter can be an ORed combination of:
* PABLIO_READ, PABLIO_WRITE, or PABLIO_READ_WRITE,
* and either PABLIO_MONO or PABLIO_STEREO
*/
PaError OpenAudioStream(PABLIO_Stream ** rwblPtr, double sampleRate, ␍PaSampleFormat format, long flags, int indev,
int outdev)
{
␍long bytesPerSample;
␍long doRead = 0;
␍long doWrite = 0;
␍PaError err;
␍PABLIO_Stream * aStream;
␍long minNumBuffers;
␍long numFrames;
␍
/* Allocate PABLIO_Stream structure for caller. */
aStream = (PABLIO_Stream *) malloc(sizeof(PABLIO_Stream));
␍if (aStream == NULL)
return paInsufficientMemory;
␍memset(aStream, 0, sizeof(PABLIO_Stream));
␍
/* Determine size of a sample. */
bytesPerSample = Pa_GetSampleSize(format);
␍if (bytesPerSample < 0)
␍ {
␍err = (PaError) bytesPerSample;
␍goto error;
␍}
␍aStream->samplesPerFrame = ((flags & PABLIO_MONO) != 0) ? 1 : 2;
␍aStream->bytesPerFrame = bytesPerSample * aStream->samplesPerFrame;
␍
/* Initialize PortAudio */
err = Pa_Initialize();
␍if (err != paNoError)
goto error;
␍
/* Warning: numFrames must be larger than amount of data processed per interrupt
* inside PA to prevent glitches. Just to be safe, adjust size upwards.
*/
minNumBuffers = 2 * Pa_GetMinNumBuffers(FRAMES_PER_BUFFER, sampleRate);
␍numFrames = minNumBuffers * FRAMES_PER_BUFFER;
/* The PortAudio callback runs in a high priority thread. But PABLIO
* runs in a normal foreground thread. So we may have much worse
* latency in PABLIO. So adjust latency to a safe level.
*/
{
␍const int safeLatencyMSec = 200;
␍int minLatencyMSec = (int) ((1000 * numFrames) / sampleRate);
␍if (minLatencyMSec < safeLatencyMSec)
␍ {
␍numFrames = (int) ((safeLatencyMSec * sampleRate) / 1000);
␍}
␍} ␍numFrames = RoundUpToNextPowerOf2(numFrames);
␍
/* Initialize Ring Buffers */
doRead = ((flags & PABLIO_READ) != 0);
␍doWrite = ((flags & PABLIO_WRITE) != 0);
␍if (doRead)
␍ {
␍err = PABLIO_InitFIFO(&aStream->inFIFO, numFrames, aStream->bytesPerFrame);
␍if (err != paNoError)
goto error;
␍}
␍if (doWrite)
␍ {
␍long numBytes;
␍err = PABLIO_InitFIFO(&aStream->outFIFO, numFrames, aStream->bytesPerFrame);
␍if (err != paNoError)
goto error;
/* Make Write FIFO appear full initially. */
numBytes = RingBuffer_GetWriteAvailable(&aStream->outFIFO);
␍RingBuffer_AdvanceWriteIndex(&aStream->outFIFO, numBytes);
␍}
␍
/* Open a PortAudio stream that we will use to communicate with the underlying
* audio drivers. */
err = Pa_OpenStream(␍&aStream->stream,
(doRead ? (indev > -1) ? indev : Pa_GetDefaultInputDeviceID() : paNoDevice),
(doRead ? aStream->samplesPerFrame : 0), ␍format, ␍NULL,
(doWrite ? (outdev > -1) ? outdev : Pa_GetDefaultOutputDeviceID() : paNoDevice),
(doWrite ? aStream->samplesPerFrame : 0), ␍format, ␍NULL, ␍sampleRate, ␍FRAMES_PER_BUFFER,
␍minNumBuffers, ␍paClipOff,
/* we won't output out of range samples so don't bother clipping them */
blockingIOCallback, ␍aStream);
␍if (err != paNoError)
goto error;
␍␍err = Pa_StartStream(aStream->stream);
␍if (err != paNoError)
goto error;
␍␍*rwblPtr = aStream;
␍return paNoError;
␍␍error:␍CloseAudioStream(aStream);
␍*rwblPtr = NULL;
␍return err;
␍}
␍
/************************************************************/
PaError CloseAudioStream(PABLIO_Stream * aStream)
{
␍PaError err = paNoError;
␍int bytesEmpty;
␍int byteSize = aStream->outFIFO.bufferSize;
␍␍if (aStream->stream != NULL) /* Make sure stream was opened. PLB021214 */
␍ {
/* If we are writing data, make sure we play everything written. */
if (byteSize > 0)
␍ {
␍int timeOutMSec = 2000;
␍bytesEmpty = RingBuffer_GetWriteAvailable(&aStream->outFIFO);
␍while ((bytesEmpty < byteSize) && (timeOutMSec > 0))
␍ {
␍Pa_Sleep(20);
␍timeOutMSec -= 20;
␍bytesEmpty = RingBuffer_GetWriteAvailable(&aStream->outFIFO);
␍}
␍}
␍err = Pa_StopStream(aStream->stream);
␍if (err != paNoError)
goto error;
␍err = Pa_CloseStream(aStream->stream);
␍}
␍␍error:␍Pa_Terminate();
␍PABLIO_TermFIFO(&aStream->inFIFO);
␍PABLIO_TermFIFO(&aStream->outFIFO);
␍free(aStream);
␍return err;
␍}
*/
PaError OpenAudioStream( PABLIO_Stream **rwblPtr, double sampleRate,
PaSampleFormat format, long flags, int indev, int outdev )
{
long bytesPerSample;
long doRead = 0;
long doWrite = 0;
PaError err;
PABLIO_Stream *aStream;
long minNumBuffers;
long numFrames;
/* Allocate PABLIO_Stream structure for caller. */
aStream = (PABLIO_Stream *) malloc( sizeof(PABLIO_Stream) );
if( aStream == NULL ) return paInsufficientMemory;
memset( aStream, 0, sizeof(PABLIO_Stream) );
/* Determine size of a sample. */
bytesPerSample = Pa_GetSampleSize( format );
if( bytesPerSample < 0 )
{
err = (PaError) bytesPerSample;
goto error;
}
aStream->samplesPerFrame = ((flags&PABLIO_MONO) != 0) ? 1 : 2;
aStream->bytesPerFrame = bytesPerSample * aStream->samplesPerFrame;
/* Initialize PortAudio */
err = Pa_Initialize();
if( err != paNoError ) goto error;
/* Warning: numFrames must be larger than amount of data processed per interrupt
* inside PA to prevent glitches. Just to be safe, adjust size upwards.
*/
minNumBuffers = 2 * Pa_GetMinNumBuffers( FRAMES_PER_BUFFER, sampleRate );
numFrames = minNumBuffers * FRAMES_PER_BUFFER;
/* The PortAudio callback runs in a high priority thread. But PABLIO
* runs in a normal foreground thread. So we may have much worse
* latency in PABLIO. So adjust latency to a safe level.
*/
{
const int safeLatencyMSec = 200;
int minLatencyMSec = (int) ((1000 * numFrames) / sampleRate);
if( minLatencyMSec < safeLatencyMSec )
{
numFrames = (int) ((safeLatencyMSec * sampleRate) / 1000);
}
}
numFrames = RoundUpToNextPowerOf2( numFrames );
/* Initialize Ring Buffers */
doRead = ((flags & PABLIO_READ) != 0);
doWrite = ((flags & PABLIO_WRITE) != 0);
if(doRead)
{
err = PABLIO_InitFIFO( &aStream->inFIFO, numFrames, aStream->bytesPerFrame );
if( err != paNoError ) goto error;
}
if(doWrite)
{
long numBytes;
err = PABLIO_InitFIFO( &aStream->outFIFO, numFrames, aStream->bytesPerFrame );
if( err != paNoError ) goto error;
/* Make Write FIFO appear full initially. */
numBytes = RingBuffer_GetWriteAvailable( &aStream->outFIFO );
RingBuffer_AdvanceWriteIndex( &aStream->outFIFO, numBytes );
}
/* Open a PortAudio stream that we will use to communicate with the underlying
* audio drivers. */
err = Pa_OpenStream(
&aStream->stream,
(doRead ? (indev > -1) ? indev : Pa_GetDefaultInputDeviceID() : paNoDevice),
(doRead ? aStream->samplesPerFrame : 0 ),
format,
NULL,
(doWrite ? (outdev > -1) ? outdev : Pa_GetDefaultOutputDeviceID() : paNoDevice),
(doWrite ? aStream->samplesPerFrame : 0 ),
format,
NULL,
sampleRate,
FRAMES_PER_BUFFER,
minNumBuffers,
paClipOff, /* we won't output out of range samples so don't bother clipping them */
blockingIOCallback,
aStream );
if( err != paNoError ) goto error;
err = Pa_StartStream( aStream->stream );
if( err != paNoError ) goto error;
*rwblPtr = aStream;
return paNoError;
error:
CloseAudioStream( aStream );
*rwblPtr = NULL;
return err;
}
/************************************************************/
PaError CloseAudioStream( PABLIO_Stream *aStream )
{
PaError err = paNoError;
int bytesEmpty;
int byteSize = aStream->outFIFO.bufferSize;
if( aStream->stream != NULL ) /* Make sure stream was opened. PLB021214 */
{
/* If we are writing data, make sure we play everything written. */
if( byteSize > 0 )
{
int timeOutMSec = 2000;
bytesEmpty = RingBuffer_GetWriteAvailable( &aStream->outFIFO );
while( (bytesEmpty < byteSize) && (timeOutMSec > 0) )
{
Pa_Sleep( 20 );
timeOutMSec -= 20;
bytesEmpty = RingBuffer_GetWriteAvailable( &aStream->outFIFO );
}
}
err = Pa_StopStream( aStream->stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( aStream->stream );
}
error:
Pa_Terminate();
PABLIO_TermFIFO( &aStream->inFIFO );
PABLIO_TermFIFO( &aStream->outFIFO );
free( aStream );
return err;
}
src/mod/endpoints/mod_portaudio/ringbuffer.c
+140 -160
View File
@@ -32,188 +32,168 @@
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*/
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "ringbuffer.h"
#include <string.h>
/***************************************************************************
* Initialize FIFO.
* numBytes must be power of 2, returns -1 if not.
*/
long RingBuffer_Init(RingBuffer * rbuf, long numBytes, void *dataPtr)
{
␍if (((numBytes - 1) & numBytes) != 0)
return -1; /* Not Power of two. */
␍rbuf->bufferSize = numBytes;
␍rbuf->buffer = (char *) dataPtr;
␍RingBuffer_Flush(rbuf);
␍rbuf->bigMask = (numBytes * 2) - 1;
␍rbuf->smallMask = (numBytes) - 1;
␍return 0;
␍}
*/
long RingBuffer_Init( RingBuffer *rbuf, long numBytes, void *dataPtr )
{
if( ((numBytes-1) & numBytes) != 0) return -1; /* Not Power of two. */
rbuf->bufferSize = numBytes;
rbuf->buffer = (char *)dataPtr;
RingBuffer_Flush( rbuf );
rbuf->bigMask = (numBytes*2)-1;
rbuf->smallMask = (numBytes)-1;
return 0;
}
/***************************************************************************
** Return number of bytes available for reading. */
long RingBuffer_GetReadAvailable( RingBuffer *rbuf )
{
return ( (rbuf->writeIndex - rbuf->readIndex) & rbuf->bigMask );
}
/***************************************************************************
** Return number of bytes available for writing. */
long RingBuffer_GetWriteAvailable( RingBuffer *rbuf )
{
return ( rbuf->bufferSize - RingBuffer_GetReadAvailable(rbuf));
}
/***************************************************************************
** Return number of bytes available for reading. */
long RingBuffer_GetReadAvailable(RingBuffer * rbuf)
{
␍return ((rbuf->writeIndex - rbuf->readIndex) & rbuf->bigMask);
␍}
** Clear buffer. Should only be called when buffer is NOT being read. */
void RingBuffer_Flush( RingBuffer *rbuf )
{
rbuf->writeIndex = rbuf->readIndex = 0;
}
/***************************************************************************
** Return number of bytes available for writing. */
long RingBuffer_GetWriteAvailable(RingBuffer * rbuf)
{
␍return (rbuf->bufferSize - RingBuffer_GetReadAvailable(rbuf));
␍}
␍
/***************************************************************************
** Clear buffer. Should only be called when buffer is NOT being read. */
void RingBuffer_Flush(RingBuffer * rbuf)
{
␍rbuf->writeIndex = rbuf->readIndex = 0;
␍} ␍
/***************************************************************************
** Get address of region(s) to which we can write data.
** If the region is contiguous, size2 will be zero.
** If non-contiguous, size2 will be the size of second region.
** Returns room available to be written or numBytes, whichever is smaller.
*/
long RingBuffer_GetWriteRegions(RingBuffer * rbuf, long numBytes, ␍void **dataPtr1, long *sizePtr1, ␍void **dataPtr2,
long *sizePtr2)
{
␍long index;
␍long available = RingBuffer_GetWriteAvailable(rbuf);
␍if (numBytes > available)
numBytes = available;
/* Check to see if write is not contiguous. */
index = rbuf->writeIndex & rbuf->smallMask;
␍if ((index + numBytes) > rbuf->bufferSize)
␍ {
/* Write data in two blocks that wrap the buffer. */
long firstHalf = rbuf->bufferSize - index;
␍*dataPtr1 = &rbuf->buffer[index];
␍*sizePtr1 = firstHalf;
␍*dataPtr2 = &rbuf->buffer[0];
␍*sizePtr2 = numBytes - firstHalf;
␍}
else
␍ {
␍*dataPtr1 = &rbuf->buffer[index];
␍*sizePtr1 = numBytes;
␍*dataPtr2 = NULL;
␍*sizePtr2 = 0;
␍}
␍return numBytes;
␍}
␍␍
*/
long RingBuffer_GetWriteRegions( RingBuffer *rbuf, long numBytes,
void **dataPtr1, long *sizePtr1,
void **dataPtr2, long *sizePtr2 )
{
long index;
long available = RingBuffer_GetWriteAvailable( rbuf );
if( numBytes > available ) numBytes = available;
/* Check to see if write is not contiguous. */
index = rbuf->writeIndex & rbuf->smallMask;
if( (index + numBytes) > rbuf->bufferSize )
{
/* Write data in two blocks that wrap the buffer. */
long firstHalf = rbuf->bufferSize - index;
*dataPtr1 = &rbuf->buffer[index];
*sizePtr1 = firstHalf;
*dataPtr2 = &rbuf->buffer[0];
*sizePtr2 = numBytes - firstHalf;
}
else
{
*dataPtr1 = &rbuf->buffer[index];
*sizePtr1 = numBytes;
*dataPtr2 = NULL;
*sizePtr2 = 0;
}
return numBytes;
}
/***************************************************************************
*/
long RingBuffer_AdvanceWriteIndex(RingBuffer * rbuf, long numBytes)
{
␍return rbuf->writeIndex = (rbuf->writeIndex + numBytes) & rbuf->bigMask;
␍}
␍
*/
long RingBuffer_AdvanceWriteIndex( RingBuffer *rbuf, long numBytes )
{
return rbuf->writeIndex = (rbuf->writeIndex + numBytes) & rbuf->bigMask;
}
/***************************************************************************
** Get address of region(s) from which we can read data.
** If the region is contiguous, size2 will be zero.
** If non-contiguous, size2 will be the size of second region.
** Returns room available to be written or numBytes, whichever is smaller.
*/
long RingBuffer_GetReadRegions(RingBuffer * rbuf, long numBytes, ␍void **dataPtr1, long *sizePtr1, ␍void **dataPtr2,
long *sizePtr2)
{
␍long index;
␍long available = RingBuffer_GetReadAvailable(rbuf);
␍if (numBytes > available)
numBytes = available;
/* Check to see if read is not contiguous. */
index = rbuf->readIndex & rbuf->smallMask;
␍if ((index + numBytes) > rbuf->bufferSize)
␍ {
/* Write data in two blocks that wrap the buffer. */
long firstHalf = rbuf->bufferSize - index;
␍*dataPtr1 = &rbuf->buffer[index];
␍*sizePtr1 = firstHalf;
␍*dataPtr2 = &rbuf->buffer[0];
␍*sizePtr2 = numBytes - firstHalf;
␍}
else
␍ {
␍*dataPtr1 = &rbuf->buffer[index];
␍*sizePtr1 = numBytes;
␍*dataPtr2 = NULL;
␍*sizePtr2 = 0;
␍}
␍return numBytes;
␍}
*/
long RingBuffer_GetReadRegions( RingBuffer *rbuf, long numBytes,
void **dataPtr1, long *sizePtr1,
void **dataPtr2, long *sizePtr2 )
{
long index;
long available = RingBuffer_GetReadAvailable( rbuf );
if( numBytes > available ) numBytes = available;
/* Check to see if read is not contiguous. */
index = rbuf->readIndex & rbuf->smallMask;
if( (index + numBytes) > rbuf->bufferSize )
{
/* Write data in two blocks that wrap the buffer. */
long firstHalf = rbuf->bufferSize - index;
*dataPtr1 = &rbuf->buffer[index];
*sizePtr1 = firstHalf;
*dataPtr2 = &rbuf->buffer[0];
*sizePtr2 = numBytes - firstHalf;
}
else
{
*dataPtr1 = &rbuf->buffer[index];
*sizePtr1 = numBytes;
*dataPtr2 = NULL;
*sizePtr2 = 0;
}
return numBytes;
}
/***************************************************************************
*/
long RingBuffer_AdvanceReadIndex( RingBuffer *rbuf, long numBytes )
{
return rbuf->readIndex = (rbuf->readIndex + numBytes) & rbuf->bigMask;
}
/***************************************************************************
*/
long RingBuffer_AdvanceReadIndex(RingBuffer * rbuf, long numBytes)
{
␍return rbuf->readIndex = (rbuf->readIndex + numBytes) & rbuf->bigMask;
␍}
␍
/***************************************************************************
** Return bytes written. */
long RingBuffer_Write(RingBuffer * rbuf, void *data, long numBytes)
{
␍long size1, size2, numWritten;
␍void *data1, *data2;
␍numWritten = RingBuffer_GetWriteRegions(rbuf, numBytes, &data1, &size1, &data2, &size2);
␍if (size2 > 0)
␍ {
␍␍memcpy(data1, data, size1);
␍data = ((char *) data) + size1;
␍memcpy(data2, data, size2);
␍}
else
␍ {
␍memcpy(data1, data, size1);
␍}
␍RingBuffer_AdvanceWriteIndex(rbuf, numWritten);
␍return numWritten;
␍}
␍
/***************************************************************************
** Return bytes read. */
long RingBuffer_Read(RingBuffer * rbuf, void *data, long numBytes)
{
␍long size1, size2, numRead;
␍void *data1, *data2;
␍numRead = RingBuffer_GetReadRegions(rbuf, numBytes, &data1, &size1, &data2, &size2);
␍if (size2 > 0)
␍ {
␍memcpy(data, data1, size1);
␍data = ((char *) data) + size1;
␍memcpy(data, data2, size2);
␍}
else
␍ {
␍memcpy(data, data1, size1);
␍}
␍RingBuffer_AdvanceReadIndex(rbuf, numRead);
␍return numRead;
␍}
** Return bytes written. */
long RingBuffer_Write( RingBuffer *rbuf, void *data, long numBytes )
{
long size1, size2, numWritten;
void *data1, *data2;
numWritten = RingBuffer_GetWriteRegions( rbuf, numBytes, &data1, &size1, &data2, &size2 );
if( size2 > 0 )
{
memcpy( data1, data, size1 );
data = ((char *)data) + size1;
memcpy( data2, data, size2 );
}
else
{
memcpy( data1, data, size1 );
}
RingBuffer_AdvanceWriteIndex( rbuf, numWritten );
return numWritten;
}
/***************************************************************************
** Return bytes read. */
long RingBuffer_Read( RingBuffer *rbuf, void *data, long numBytes )
{
long size1, size2, numRead;
void *data1, *data2;
numRead = RingBuffer_GetReadRegions( rbuf, numBytes, &data1, &size1, &data2, &size2 );
if( size2 > 0 )
{
memcpy( data, data1, size1 );
data = ((char *)data) + size1;
memcpy( data, data2, size2 );
}
else
{
memcpy( data, data1, size1 );
}
RingBuffer_AdvanceReadIndex( rbuf, numRead );
return numRead;
}