static void oss_output_clear_buffers(void)
{
#ifdef SNDCTL_DSP_RESET
ioctl(oss_fd, SNDCTL_DSP_RESET);
#endif
ringbuf_drain(oss_output_buffer);
}
static gboolean oss_output_stop(gboolean must_flush)
{
if (oss_fd == -1) return TRUE;
if (must_flush)
while (ringbuf_available(oss_output_buffer)>0) {
oss_output_flush(NULL,NULL,NULL);
do_yield(TRUE);
}
else
oss_output_clear_buffers();
close(oss_fd);
oss_fd = -1;
/* printf("oss_stop: oss_delay_time = %f\n",oss_delay_time); */
ringbuf_drain(oss_output_buffer);
return must_flush;
}
bool hfp_hf_send_command(struct hfp_hf *hfp, hfp_response_func_t resp_cb,
void *user_data, const char *format, ...)
{
va_list ap;
char *fmt;
int len;
struct cmd_response *cmd;
if (!hfp || !format || !resp_cb)
return false;
if (asprintf(&fmt, "%s\r", format) < 0)
return false;
cmd = new0(struct cmd_response, 1);
if (!cmd) {
free(fmt);
return false;
}
va_start(ap, format);
len = ringbuf_vprintf(hfp->write_buf, fmt, ap);
va_end(ap);
free(fmt);
if (len < 0) {
free(cmd);
return false;
}
cmd->resp_cb = resp_cb;
cmd->user_data = user_data;
if (!queue_push_tail(hfp->cmd_queue, cmd)) {
ringbuf_drain(hfp->write_buf, len);
free(cmd);
return false;
}
hf_wakeup_writer(hfp);
return true;
}
static void process_input(struct hfp_gw *hfp)
{
char *str, *ptr;
size_t len, count;
bool free_ptr = false;
bool read_again;
do {
str = ringbuf_peek(hfp->read_buf, 0, &len);
if (!str)
return;
ptr = memchr(str, '\r', len);
if (!ptr) {
char *str2;
size_t len2;
/*
* If there is no more data in ringbuffer,
* it's just an incomplete command.
*/
if (len == ringbuf_len(hfp->read_buf))
return;
str2 = ringbuf_peek(hfp->read_buf, len, &len2);
if (!str2)
return;
ptr = memchr(str2, '\r', len2);
if (!ptr)
return;
*ptr = '\0';
count = len2 + len;
ptr = malloc(count);
if (!ptr)
return;
memcpy(ptr, str, len);
memcpy(ptr + len, str2, len2);
free_ptr = true;
str = ptr;
} else {
count = ptr - str;
*ptr = '\0';
}
if (!handle_at_command(hfp, str))
/*
* Command is not handled that means that was some
* trash. Let's skip that and keep reading from ring
* buffer.
*/
read_again = true;
else
/*
* Command has been handled. If we are waiting for a
* result from upper layer, we can stop reading. If we
* already reply i.e. ERROR on unknown command, then we
* can keep reading ring buffer. Actually ring buffer
* should be empty but lets just look there.
*/
read_again = !hfp->result_pending;
ringbuf_drain(hfp->read_buf, count + 1);
if (free_ptr)
free(ptr);
} while (read_again);
}
static void hf_process_input(struct hfp_hf *hfp)
{
char *str, *ptr, *str2, *tmp;
size_t len, count, offset, len2;
bool free_tmp = false;
str = ringbuf_peek(hfp->read_buf, 0, &len);
if (!str)
return;
offset = 0;
ptr = find_cr_lf(str, len);
while (ptr) {
count = ptr - (str + offset);
if (count == 0) {
/* 2 is for <cr><lf> */
offset += 2;
} else {
*ptr = '\0';
hf_call_prefix_handler(hfp, str + offset);
offset += count + 2;
}
ptr = find_cr_lf(str + offset, len - offset);
}
/*
* Just check if there is no wrapped data in ring buffer.
* Should not happen too often
*/
if (len == ringbuf_len(hfp->read_buf))
goto done;
str2 = ringbuf_peek(hfp->read_buf, len, &len2);
if (!str2)
goto done;
ptr = find_cr_lf(str2, len2);
if (!ptr) {
/* Might happen that we wrap between \r and \n */
ptr = memchr(str2, '\n', len2);
if (!ptr)
goto done;
}
count = ptr - str2;
if (count) {
*ptr = '\0';
tmp = malloc(len + count);
if (!tmp)
goto done;
/* "str" here is not a string so we need to use memcpy */
memcpy(tmp, str, len);
memcpy(tmp + len, str2, count);
free_tmp = true;
} else {
str[len-1] = '\0';
tmp = str;
}
hf_call_prefix_handler(hfp, tmp);
offset += count;
done:
ringbuf_drain(hfp->read_buf, offset);
if (free_tmp)
free(tmp);
}
