int CIPICOMConnectionV6::send(std::string input, int& nof_cmd, int& tx_id, channel_type channel)
{
if (!opened)
{
LOGER((CLogger::DEBUG_ERROR,"Send Error, No Session!"));
return 0;
}
int retval = 0;
if ((active_channel == shared_channel && channel == default_channel) || channel == shared_channel)
{
tx_id = 0;
nof_cmd = 1;
retval = send_internal(input);
}
else
{
retval = send_tid_internal(input, nof_cmd, tx_id, channel_to_socket(channel));
}
if (retval) {
LOGER((CLogger::DEBUG_INFO,"Send on %s OK: '%s'",get_channel_name(channel).c_str(),input.c_str()));
} else {
LOGER((CLogger::DEBUG_ERROR,"Send on %s ERROR: '%s'",get_channel_name(channel).c_str(),input.c_str()));
}
return retval;
}
int CIPICOMConnectionV6::receive(std::string& output, int tx_id, int nof_exp_resp, int expect_unsolicited, channel_type channel)
{
if (!opened)
{
LOGER((CLogger::DEBUG_ERROR,"Recv Error, No Session!"));
return 0;
}
int retval = 0;
if ((active_channel == shared_channel && channel == default_channel) || channel == shared_channel)
{
retval = receive_internal(output, expect_unsolicited);
}
else
{
retval = receive_tid_internal(tx_id, nof_exp_resp, output, channel_to_socket(channel), expect_unsolicited);
}
if (retval) {
LOGER((CLogger::DEBUG_INFO,"Recv on %s OK: '%s'",get_channel_name(channel).c_str(),output.c_str()));
} else {
LOGER((CLogger::DEBUG_ERROR,"Recv on %s ERROR: '%s'",get_channel_name(channel).c_str(),output.c_str()));
}
return retval;
}
bool CIPICOMConnectionV6::send_tid_internal(std::string input, int& nof_commands_sent, int& tx_id, int sock)
{
nof_commands_sent = 0;
// Must strip at@ from command when sending over sapn socket
std::string::size_type pos;
if ((pos = input.find("at@")) != std::string::npos ||
(pos = input.find("AT@")) != std::string::npos)
{
input.erase(pos, 3);
}
// Command format:
// 1. at@ is removed
// 2. <tid><space><command><0>
std::stringstream ss;
ss << tid << " " << input;
std::string out = ss.str();
out.append("\0", 1);
tx_id = tid;
if (ipicom->send(sock, out) < 0)
{
LOGER((CLogger::DEBUG_ERROR,"Send on %s ERROR: '%s'", get_channel_name(active_channel).c_str(), process_for_log(input).c_str()));
return false;
}
else
LOGER((CLogger::DEBUG_INFO,"Send on %s OK: '%s'", get_channel_name(active_channel).c_str(), process_for_log(input).c_str()));
nof_commands_sent = std::count(input.begin(), input.end(), ';') + 1;
tid += nof_commands_sent;
return true;
}
int CIPICOMConnectionV6::send(std::string input)
{
if (!opened)
{
LOGER((CLogger::DEBUG_ERROR,"Send Error, No Session!"));
return 0;
}
int retval = 0;
if (active_channel == shared_channel)
{
retval = send_internal(input);
}
else
{
int nof_commands;
int id;
retval = send_tid_internal(input, nof_commands, id, channel_to_socket());
}
if (retval) {
LOGER((CLogger::DEBUG_INFO,"Send on %s OK: '%s'",get_channel_name(active_channel).c_str(),input.c_str()));
} else {
LOGER((CLogger::DEBUG_ERROR,"Send on %s ERROR: '%s'",get_channel_name(active_channel).c_str(),input.c_str()));
}
return retval;
}
bool CIPICOMConnectionV6::receive_internal(std::string& output, int expect_unsolicited)
{
int recv_result;
int dummy;
recv_result = receive_wrapp(socket_shared, output, dummy);
// Remove newlines in the string
//std::string::size_type pos_line = output.find("\r\n");
//while(pos_line != std::string::npos)
//{
// output.replace(pos_line, 2, " ");
// pos_line = output.find("\r\n");
//}
if (recv_result == 0) // Means OK
{
if (output.find("OK") != std::string::npos)
{
LOGER((CLogger::DEBUG_INFO,"Recv on %s OK: '%s'", get_channel_name(shared_channel).c_str(),process_for_log(output).c_str()));
return true;
} else {
LOGER((CLogger::DEBUG_INFO,"Recv on %s ERROR: '%s'", get_channel_name(shared_channel).c_str(),process_for_log(output).c_str()));
return false;
}
}
else if (recv_result > 0) // means unsolicited data is received
{
if (expect_unsolicited)
{
return true;
}
output.clear();
return receive_internal(output, expect_unsolicited);
}
else if (recv_result == -1) // Error from ipicom
{
return false;
}
else if (recv_result == -2) // Error from target
{
return false;
}
else if (recv_result == -3) // Received partial response
{
std::string incomplete_output;
if (receive_internal(incomplete_output, expect_unsolicited))
{
output += incomplete_output;
return true;
}
return false;
}
return false;
}
bool CIPICOMConnectionV6::send_internal(std::string input)
{
// on AT socket commands must be terminated with \r
input.append("\r");
int retval = ipicom->send(socket_shared, input) != 0;
if (retval) {
LOGER((CLogger::DEBUG_INFO,"Send on %s OK: '%s'",get_channel_name(active_channel).c_str(), process_for_log(input).c_str()));
} else {
LOGER((CLogger::DEBUG_ERROR,"Send on %s ERROR: '%s'",get_channel_name(active_channel).c_str(), process_for_log(input).c_str()));
}
return retval == 1;
}
void av_get_channel_layout_string(char *buf, int buf_size,
int nb_channels, int64_t channel_layout)
{
int i;
if (nb_channels <= 0)
nb_channels = av_get_channel_layout_nb_channels(channel_layout);
for (i = 0; channel_layout_map[i].name; i++)
if (nb_channels == channel_layout_map[i].nb_channels &&
channel_layout == channel_layout_map[i].layout) {
av_strlcpy(buf, channel_layout_map[i].name, buf_size);
return;
}
snprintf(buf, buf_size, "%d channels", nb_channels);
if (channel_layout) {
int i,ch;
av_strlcat(buf, " (", buf_size);
for(i=0,ch=0; i<64; i++) {
if ((channel_layout & (1L<<i))) {
const char *name = get_channel_name(i);
if (name) {
if (ch>0) av_strlcat(buf, "|", buf_size);
av_strlcat(buf, name, buf_size);
}
ch++;
}
}
av_strlcat(buf, ")", buf_size);
}
}
void av_bprint_channel_layout(struct AVBPrint *bp,
int nb_channels, uint64_t channel_layout)
{
int i;
if (nb_channels <= 0)
nb_channels = av_get_channel_layout_nb_channels(channel_layout);
for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map); i++)
if (nb_channels == channel_layout_map[i].nb_channels &&
channel_layout == channel_layout_map[i].layout) {
av_bprintf(bp, "%s", channel_layout_map[i].name);
return;
}
av_bprintf(bp, "%d channels", nb_channels);
if (channel_layout) {
int i, ch;
av_bprintf(bp, " (");
for (i = 0, ch = 0; i < 64; i++) {
if ((channel_layout & (UINT64_C(1) << i))) {
const char *name = get_channel_name(i);
if (name) {
if (ch > 0)
av_bprintf(bp, "+");
av_bprintf(bp, "%s", name);
}
ch++;
}
}
av_bprintf(bp, ")");
}
}
const char *av_get_channel_name(uint64_t channel)
{
int i;
if (av_get_channel_layout_nb_channels(channel) != 1)
return NULL;
for (i = 0; i < 64; i++)
if ((1ULL<<i) & channel)
return get_channel_name(i);
return NULL;
}
int CIPICOMConnectionV6::timeout(int delay)
{
if (!delay) delay = 2500;
int retval = ipicom->socket_set_opt(channel_to_socket(), IPICOM_SOCK_OPT_LVL_SESSION, IPICOM_SOCK_OPT_TIMEOUT, &delay, sizeof(delay));
if (!retval)
{
LOGER((CLogger::DEBUG_INFO,"Set timeout for %s socket to %dms",get_channel_name(active_channel).c_str(),delay));
}
return !retval;
}
static GstFlowReturn
gst_flite_test_src_create (GstBaseSrc * basesrc, guint64 offset,
guint length, GstBuffer ** buffer)
{
GstFliteTestSrc *src;
int n_bytes;
src = GST_FLITE_TEST_SRC (basesrc);
n_bytes = src->info.channels * sizeof (gint16) * src->samples_per_buffer;
while (gst_adapter_available (src->adapter) < n_bytes) {
GstBuffer *buf;
char *text;
int i;
GstMapInfo map;
gint16 *data;
cst_wave *wave;
gsize size;
text = get_channel_name (src, src->channel);
wave = flite_text_to_wave (text, src->voice);
g_free (text);
cst_wave_resample (wave, src->info.rate);
GST_DEBUG ("type %s, sample_rate %d, num_samples %d, num_channels %d",
wave->type, wave->sample_rate, wave->num_samples, wave->num_channels);
size = src->info.channels * sizeof (gint16) * wave->num_samples;
buf = gst_buffer_new_and_alloc (size);
gst_buffer_map (buf, &map, GST_MAP_WRITE);
data = (gint16 *) map.data;
memset (data, 0, size);
for (i = 0; i < wave->num_samples; i++) {
data[i * src->info.channels + src->channel] = wave->samples[i];
}
gst_buffer_unmap (buf, &map);
src->channel++;
if (src->channel == src->info.channels) {
src->channel = 0;
}
gst_adapter_push (src->adapter, buf);
}
*buffer = gst_adapter_take_buffer (src->adapter, n_bytes);
return GST_FLOW_OK;
}
void bgav_qt_chan_dump(int indent, qt_chan_t * chan)
{
const channel_label_t * channel_labels;
int num_channels;
int i, j;
uint32_t mask;
bgav_dprintf( "channel description (chan)\n");
bgav_dprintf( " version %d\n", chan->version);
bgav_dprintf( " flags %d\n", chan->flags);
bgav_dprintf( " mChannelLayoutTag: 0x%08x", chan->mChannelLayoutTag);
if(chan->mChannelLayoutTag == CHANNEL_LAYOUT_UseChannelDescriptions)
{
bgav_dprintf( " [Use channel decriptions]\n");
}
else if(chan->mChannelLayoutTag == CHANNEL_LAYOUT_UseChannelBitmap)
{
bgav_dprintf( " [Use channel bitmap]\n");
}
else
{
channel_labels = get_channel_locations(chan->mChannelLayoutTag, &num_channels);
bgav_dprintf( " [");
if(channel_labels)
{
for(i = 0; i < num_channels; i++)
{
bgav_dprintf( "%s", get_channel_name(channel_labels[i]));
if(i < num_channels-1)
bgav_dprintf( ", ");
}
}
else
bgav_dprintf( "Not available");
bgav_dprintf( "]\n");
}
bgav_dprintf( " mChannelBitmap: 0x%08x", chan->mChannelBitmap);
if(chan->mChannelLayoutTag == CHANNEL_LAYOUT_UseChannelBitmap)
{
bgav_dprintf( " [");
j = 0;
mask = 1;
for(i = 0; i < 32; i++)
{
if(chan->mChannelBitmap & mask)
{
if(j)
bgav_dprintf( ", ");
bgav_dprintf( "%s", get_channel_name(channel_bit_2_channel_label(mask)));
j++;
}
mask <<= 1;
}
bgav_dprintf( "]\n");
}
else
bgav_dprintf( "\n");
bgav_dprintf( " mNumberChannelDescriptions: %d\n", chan->mNumberChannelDescriptions);
for(i = 0; i < chan->mNumberChannelDescriptions; i++)
{
bgav_dprintf( " mChannelLabel[%d]: 0x%08x [%s]\n", i,
chan->ChannelDescriptions[i].mChannelLabel, get_channel_name(chan->ChannelDescriptions[i].mChannelLabel));
bgav_dprintf( " mChannelFlags[%d]: 0x%08x\n", i,
chan->ChannelDescriptions[i].mChannelFlags);
bgav_dprintf( " mCoordinates[%d]: [%f %f %f]\n", i,
chan->ChannelDescriptions[i].mCoordinates[0],
chan->ChannelDescriptions[i].mCoordinates[1],
chan->ChannelDescriptions[i].mCoordinates[2]);
}
}
void javautil_vprintf(int severity, int channelID, int isolateID, char *msg, va_list vl) {
char *str = 0;
char tempBuffer[CONVERSION_BUFFER_SIZE];
union Printable_t {
int i;
int x;
char c;
char *s;
} Printable;
char* separator = " - ";
javacall_time_milliseconds ms;
ms = javacall_time_get_clock_milliseconds();
/*
msg is the last argument specified; all
others must be accessed using the variable-
argument macros.
*/
str = convertInt2String(ms,tempBuffer);
javacall_print(str);
javacall_print(separator);
str = get_channel_name(channelID);
javacall_print(str);
javacall_print(separator);
str = get_severity_name(severity);
javacall_print(str);
javacall_print(separator);
str = convertInt2String(isolateID,tempBuffer);
javacall_print(str);
javacall_print(separator);
if(msg == NULL) {
javacall_print("NULL\n");
return;
}
while(*msg) {
if((*msg == '%') && (*(msg+1) == '%')) {
msg++;
javautil_putchar(*msg);
msg++;
} else if(*msg != '%') {
javautil_putchar(*msg);
msg++;
} else {
msg++;
switch(*msg) { /* Type to expect.*/
/*Need to revisit: %ld and %lld ?*/
case 'u':
case 'i':
case 'd': /* integer */
Printable.i = va_arg( vl, int );
str = convertInt2String(Printable.i,tempBuffer);
javacall_print(str);
break;
case 'x': /* hexadecimal */
Printable.x = va_arg( vl, int );
str = convertHexa2String(Printable.x,tempBuffer);
javacall_print(str);
break;
case 'c': /* character */
Printable.c = (char)va_arg( vl, int );
javautil_putchar(Printable.c);
break;
case 's': /* string */
Printable.s = va_arg( vl, char * );
javacall_print(Printable.s);
break;
default:
javacall_print("\nUnsupported type. Cant print %");
javautil_putchar(*msg);
javacall_print(".\n");
break;
}/*end of switch*/
msg++;
}/*end of else*/
}/*end of while*/
javacall_print("\n");
}/* end of javautil_printf */
