cmm/src/voicebuf.c - vendor/mindspeed/drivers - Git at Google

  /*
   *  voicebuf.c
   *
   *  Copyright (C) 2010 Mindspeed Technologies, Inc.
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */


 #include "cmm.h"
 #include "fpp.h"
 #include "cmmd.h"
 #include "voicebuf.h"

 static int voice_file_fd[VOICE_FILE_MAX];

 int voice_file_load(FCI_CLIENT *fci_handle, cmmd_voice_file_load_cmd_t *cmd, u_int16_t *res_buf, u_int16_t *res_len)
 {
 	fpp_voice_buffer_load_cmd_t fpp_cmd;
 	struct usr_scatter_list sc;
 	int file_fd;
 	int file_size;
 	int buf_fd;
 	int i;
 	int rc = 0;

 	cmm_print(DEBUG_INFO, "%s\n", __func__);
 	*res_len = 2;

 	if (cmd->file_id >= VOICE_FILE_MAX)
 	{
 		cmm_print(DEBUG_ERROR, "%s: fileid(%d) out of range\n", __func__, cmd->file_id);
 		res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
 		goto err0;
 	}

 	if (voice_file_fd[cmd->file_id])
 	{
 		cmm_print(DEBUG_ERROR, "%s: fileid(%d) already loaded\n", __func__, cmd->file_id);
 		res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
 		goto err0;
 	}

 	file_fd = open(cmd->filename, O_RDONLY, 0);
 	if (file_fd < 0)
 	{
 		cmm_print(DEBUG_ERROR, "%s: open(%s) error, %s\n", __func__, cmd->filename, strerror(errno));
 		rc = -1;
 		goto err0;
 	}

 	buf_fd = open(MEMBUF_CHAR_DEVNAME, O_WRONLY, 0);
 	if (buf_fd < 0)
 	{
 		cmm_print(DEBUG_ERROR, "%s: open(%s) error, %s\n", __func__, MEMBUF_CHAR_DEVNAME, strerror(errno));
 		rc = -1;
 		goto err1;
 	}

 	file_size = lseek(file_fd, 0, SEEK_END);
 	if (file_size < 0)
 	{
 		cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
 		rc = -1;
 		goto err2;
 	}

 	rc = lseek(buf_fd, file_size, SEEK_SET);
 	if (rc < 0)
 	{
 		cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
 		goto err2;
 	}

 	rc = lseek(file_fd, 0, SEEK_SET);
 	if (rc < 0)
 	{
 		cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
 		goto err2;
 	}

 	rc = lseek(buf_fd, 0, SEEK_SET);
 	if (rc < 0)
 	{
 		cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
 		goto err2;
 	}

 	while (1)
 	{
 		char buf[4096];
 		int len;

 		len = read(file_fd, buf, 4096);
 		if (!len)
 			break;

 		if (len < 0)
 		{
 			if (errno != EINTR)
 			{
 				cmm_print(DEBUG_ERROR, "%s: read() error, %s\n", __func__, strerror(errno));
 				rc = -1;
 				goto err2;
 			}
 		}

 		while (len)
 		{
 			rc = write(buf_fd, buf, len);
 			if (rc <= 0)
 			{
 				if (errno != EINTR)
 				{
 					cmm_print(DEBUG_ERROR, "%s: write() error, %s\n", __func__, strerror(errno));
 					goto err2;
 				}

 				continue;
 			}

 			len -= rc;
 		}
 	}

 	rc = ioctl(buf_fd, MEMBUF_GET_SCATTER, &sc);
 	if (rc < 0)
 	{
 		cmm_print(DEBUG_ERROR, "%s: ioctl() error, %s\n", __func__, strerror(errno));
 		goto err2;
 	}

 	fpp_cmd.buffer_id = cmd->file_id;
 	fpp_cmd.payload_type = cmd->payload_type;
 	fpp_cmd.frame_size = cmd->frame_size;

 	fpp_cmd.entries = sc.entries;
 	fpp_cmd.data_len = file_size;

 	for (i = 0; i < sc.entries; i++)
 	{
 		fpp_cmd.page_order[i] = sc.pg_order[i];
 		fpp_cmd.addr[i] = sc.addr[i];

 		cmm_print(DEBUG_INFO, "%s: %d %x %x\n", __func__, i, fpp_cmd.page_order[i], fpp_cmd.addr[i]);
 	}

 	cmm_print(DEBUG_COMMAND, "%s: Send FPP_CMD_VOICE_BUFFER_LOAD\n", __func__);

 	rc = fci_cmd(fci_handle, FPP_CMD_VOICE_BUFFER_LOAD, (u_int16_t *) &fpp_cmd, sizeof(fpp_cmd), res_buf, res_len);
 	if (rc == 0 && res_buf[0] == FPP_ERR_OK)
 	{
 		voice_file_fd[cmd->file_id] = buf_fd;
 	}
 	else
 	{
 		if (rc < 0)
 			cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_LOAD failed, '%s'\n", __func__, strerror(errno));
 		else
 			cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_LOAD failed, %d\n", __func__, res_buf[0]);
 		goto err2;
 	}

 	close(file_fd);

 	return rc;

 err2:
 	close(buf_fd);

 err1:
 	close(file_fd);

 err0:
 	return rc;
 }


 int voice_file_unload(FCI_CLIENT *fci_handle, cmmd_voice_file_unload_cmd_t *cmd, u_int16_t *res_buf, u_int16_t *res_len)
 {
 	fpp_voice_buffer_unload_cmd_t fpp_cmd;
 	int rc = 0;

 	cmm_print(DEBUG_INFO, "%s:\n", __func__);

 	*res_len = 2;

 	if (cmd->file_id >= VOICE_FILE_MAX)
 	{
 		cmm_print(DEBUG_ERROR, "%s: fileid(%d) out of range\n", __func__, cmd->file_id);
 		res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
 		goto err;
 	}

 	if (!voice_file_fd[cmd->file_id])
 	{
 		cmm_print(DEBUG_ERROR, "%s: fileid(%d) not loaded\n", __func__, cmd->file_id);
 		res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
 		goto err;
 	}

 	fpp_cmd.buffer_id = cmd->file_id;

 	cmm_print(DEBUG_COMMAND, "%s: Send FPP_CMD_VOICE_BUFFER_UNLOAD\n", __func__);

 	rc = fci_cmd(fci_handle, FPP_CMD_VOICE_BUFFER_UNLOAD, (u_int16_t *) &fpp_cmd, sizeof(fpp_cmd), res_buf, res_len);
 	if (rc == 0 && res_buf[0] == FPP_ERR_OK)
 	{
 		close(voice_file_fd[cmd->file_id]);
 		voice_file_fd[cmd->file_id] = 0;

 	}
 	else
 	{
 		if (rc < 0)
 			cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_UNLOAD failed, '%s'\n", __func__, strerror(errno));
 		else
 			cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_UNLOAD failed, %d\n", __func__, res_buf[0]);
 		goto err;
 	}

 err:
 	return rc;
 }

 int voice_buffer_reset(FCI_CLIENT *fci_handle)
 {
 	int rc;
 	int i;

 	rc = fci_write(fci_handle, FPP_CMD_VOICE_BUFFER_RESET, 0, NULL);

 	for (i = 0; i < VOICE_FILE_MAX;i++)
 		if (voice_file_fd[i])
 		{
 			close(voice_file_fd[i]);
 			voice_file_fd[i] = 0;
 		}

 	return rc;
 }

 static void voice_buffer_set_usage(void)
 {
 	cmm_print(DEBUG_STDOUT,
 			"Usage: set voicebuf \n"
 			"\n"
 			"                                  [load] <file_id> <payload_type> <frame_size> <filename>\n"
 			"\n"
 			"                                  [unload] <file_id>\n"
 			"\n"
 			"                                  [start] <socket_id> <buffer_id> <seq_number_base> <ssrc> <timestamp_base>\n"
 			"\n"
 			"                                  [stop] <socket_id>\n"
 	          );
 }


 /* CMM client side voicebuf control */
 int cmmVoiceBufSetProcess(int argc, char *argv[], daemon_handle_t daemon_handle)
 {
 	char buf[CMM_BUF_SIZE];
 	int i = 0;
 	int rc;
 	const char* cmd_str = NULL;

 	if (argc < 1)
 	{
 		fprintf(stderr, "%s: missing arguments for voicebuf command\n", __func__);
 		goto err;
 	}

 	if (!strncasecmp(argv[i], "load", 4))
 	{
 		cmmd_voice_file_load_cmd_t cmd;

 		if (argc < 5)
 		{
 			fprintf(stderr, "%s: missing arguments for voicebuf load command\n", __func__);
 			goto err;
 		}

 		i++;
 		cmd.file_id = strtoul(argv[i], NULL, 0);

 		i++;
 		cmd.payload_type = strtoul(argv[i], NULL, 0);

 		i++;
 		cmd.frame_size = strtoul(argv[i], NULL, 0);

 		i++;
 		strncpy(cmd.filename, argv[i], CMMD_VOICE_FILE_MAX_NAMESIZE);

 		rc = cmmSendToDaemon(daemon_handle, CMMD_CMD_VOICE_FILE_LOAD, &cmd, sizeof(cmd), buf);
 		cmd_str = "CMD_VOICE_FILE_LOAD";
 	}
 	else if (!strncasecmp(argv[i], "unload", 6))
 	{
 		cmmd_voice_file_unload_cmd_t cmd;

 		if (argc < 2)
 		{
 			fprintf(stderr, "%s: missing arguments for voicebuf unload command\n", __func__);
 			goto err;
 		}

 		i++;
 		cmd.file_id = strtoul(argv[i], NULL, 0);

 		rc = cmmSendToDaemon(daemon_handle, CMMD_CMD_VOICE_FILE_UNLOAD, &cmd, sizeof(cmd), buf);
 		cmd_str = "CMD_VOICE_FILE_UNLOAD";
 	}
 	else if (!strncasecmp(argv[i], "start", 5))
 	{
 		fpp_voice_buffer_start_cmd_t cmd;

 		if (argc < 6)
 		{
 			fprintf(stderr, "%s: missing arguments for voicebuf start command\n", __func__);
 			goto err;
 		}

 		i++;
 		cmd.socket_id = strtoul(argv[i], NULL, 0);

 		i++;
 		cmd.buffer_id = strtoul(argv[i], NULL, 0);

 		i++;
 		cmd.seq_number_base = strtoul(argv[i], NULL, 0);

 		i++;
 		cmd.ssrc = strtoul(argv[i], NULL, 0);

 		i++;
 		cmd.timestamp_base = strtoul(argv[i], NULL, 0);

 		rc = cmmSendToDaemon(daemon_handle, FPP_CMD_VOICE_BUFFER_START, &cmd, sizeof(cmd), buf);
 		cmd_str = "CMD_VOICE_BUFFER_START";
 	}
 	else if (!strncasecmp(argv[i], "stop", 4))
 	{
 		fpp_voice_buffer_stop_cmd_t cmd;

 		if (argc < 2)
 		{
 			fprintf(stderr, "%s: missing arguments for voicebuf stop command\n", __func__);
 			goto err;
 		}

 		i++;
 		cmd.socket_id = strtoul(argv[i], NULL, 0);

 		rc = cmmSendToDaemon(daemon_handle, FPP_CMD_VOICE_BUFFER_STOP, &cmd, sizeof(cmd), buf);
 		cmd_str = "CMD_VOICE_BUFFER_STOP";
 	}
 	else
 		goto err;

 	if (rc == 2)
 	{
 		if (((u_int16_t*)buf)[0] != CMMD_ERR_OK)
 		{
 			fprintf(stdout, "%s: error sending %s: %d\n", __func__, cmd_str, ((u_int16_t*)buf)[0]);
 			return -1;
 		}
 	}
 	else
 	{
 		if (rc > 0)
 			fprintf(stdout, "%s: unexpected response size received for %s: %d\n", __func__, cmd_str, rc);
 		else
 			fprintf(stdout, "%s: error sending %s: '%s'\n", __func__, cmd_str, strerror(errno));
 		return -1;
 	}

 	return 0;

 err:
 	/* print usage */
 	voice_buffer_set_usage();

 	return -1;
 }
	/*
	* voicebuf.c
	*
	* Copyright (C) 2010 Mindspeed Technologies, Inc.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/


	#include "cmm.h"
	#include "fpp.h"
	#include "cmmd.h"
	#include "voicebuf.h"

	static int voice_file_fd[VOICE_FILE_MAX];

	int voice_file_load(FCI_CLIENT fci_handle, cmmd_voice_file_load_cmd_t cmd, u_int16_t res_buf, u_int16_t res_len)
	{
	fpp_voice_buffer_load_cmd_t fpp_cmd;
	struct usr_scatter_list sc;
	int file_fd;
	int file_size;
	int buf_fd;
	int i;
	int rc = 0;

	cmm_print(DEBUG_INFO, "%s\n", __func__);
	*res_len = 2;

	if (cmd->file_id >= VOICE_FILE_MAX)
	{
	cmm_print(DEBUG_ERROR, "%s: fileid(%d) out of range\n", __func__, cmd->file_id);
	res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
	goto err0;
	}

	if (voice_file_fd[cmd->file_id])
	{
	cmm_print(DEBUG_ERROR, "%s: fileid(%d) already loaded\n", __func__, cmd->file_id);
	res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
	goto err0;
	}

	file_fd = open(cmd->filename, O_RDONLY, 0);
	if (file_fd < 0)
	{
	cmm_print(DEBUG_ERROR, "%s: open(%s) error, %s\n", __func__, cmd->filename, strerror(errno));
	rc = -1;
	goto err0;
	}

	buf_fd = open(MEMBUF_CHAR_DEVNAME, O_WRONLY, 0);
	if (buf_fd < 0)
	{
	cmm_print(DEBUG_ERROR, "%s: open(%s) error, %s\n", __func__, MEMBUF_CHAR_DEVNAME, strerror(errno));
	rc = -1;
	goto err1;
	}

	file_size = lseek(file_fd, 0, SEEK_END);
	if (file_size < 0)
	{
	cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
	rc = -1;
	goto err2;
	}

	rc = lseek(buf_fd, file_size, SEEK_SET);
	if (rc < 0)
	{
	cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
	goto err2;
	}

	rc = lseek(file_fd, 0, SEEK_SET);
	if (rc < 0)
	{
	cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
	goto err2;
	}

	rc = lseek(buf_fd, 0, SEEK_SET);
	if (rc < 0)
	{
	cmm_print(DEBUG_ERROR, "%s: lseek() error, %s\n", __func__, strerror(errno));
	goto err2;
	}

	while (1)
	{
	char buf[4096];
	int len;

	len = read(file_fd, buf, 4096);
	if (!len)
	break;

	if (len < 0)
	{
	if (errno != EINTR)
	{
	cmm_print(DEBUG_ERROR, "%s: read() error, %s\n", __func__, strerror(errno));
	rc = -1;
	goto err2;
	}
	}

	while (len)
	{
	rc = write(buf_fd, buf, len);
	if (rc <= 0)
	{
	if (errno != EINTR)
	{
	cmm_print(DEBUG_ERROR, "%s: write() error, %s\n", __func__, strerror(errno));
	goto err2;
	}

	continue;
	}

	len -= rc;
	}
	}

	rc = ioctl(buf_fd, MEMBUF_GET_SCATTER, &sc);
	if (rc < 0)
	{
	cmm_print(DEBUG_ERROR, "%s: ioctl() error, %s\n", __func__, strerror(errno));
	goto err2;
	}

	fpp_cmd.buffer_id = cmd->file_id;
	fpp_cmd.payload_type = cmd->payload_type;
	fpp_cmd.frame_size = cmd->frame_size;

	fpp_cmd.entries = sc.entries;
	fpp_cmd.data_len = file_size;

	for (i = 0; i < sc.entries; i++)
	{
	fpp_cmd.page_order[i] = sc.pg_order[i];
	fpp_cmd.addr[i] = sc.addr[i];

	cmm_print(DEBUG_INFO, "%s: %d %x %x\n", __func__, i, fpp_cmd.page_order[i], fpp_cmd.addr[i]);
	}

	cmm_print(DEBUG_COMMAND, "%s: Send FPP_CMD_VOICE_BUFFER_LOAD\n", __func__);

	rc = fci_cmd(fci_handle, FPP_CMD_VOICE_BUFFER_LOAD, (u_int16_t *) &fpp_cmd, sizeof(fpp_cmd), res_buf, res_len);
	if (rc == 0 && res_buf[0] == FPP_ERR_OK)
	{
	voice_file_fd[cmd->file_id] = buf_fd;
	}
	else
	{
	if (rc < 0)
	cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_LOAD failed, '%s'\n", __func__, strerror(errno));
	else
	cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_LOAD failed, %d\n", __func__, res_buf[0]);
	goto err2;
	}

	close(file_fd);

	return rc;

	err2:
	close(buf_fd);

	err1:
	close(file_fd);

	err0:
	return rc;
	}


	int voice_file_unload(FCI_CLIENT fci_handle, cmmd_voice_file_unload_cmd_t cmd, u_int16_t res_buf, u_int16_t res_len)
	{
	fpp_voice_buffer_unload_cmd_t fpp_cmd;
	int rc = 0;

	cmm_print(DEBUG_INFO, "%s:\n", __func__);

	*res_len = 2;

	if (cmd->file_id >= VOICE_FILE_MAX)
	{
	cmm_print(DEBUG_ERROR, "%s: fileid(%d) out of range\n", __func__, cmd->file_id);
	res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
	goto err;
	}

	if (!voice_file_fd[cmd->file_id])
	{
	cmm_print(DEBUG_ERROR, "%s: fileid(%d) not loaded\n", __func__, cmd->file_id);
	res_buf[0] = CMMD_ERR_WRONG_COMMAND_PARAM;
	goto err;
	}

	fpp_cmd.buffer_id = cmd->file_id;

	cmm_print(DEBUG_COMMAND, "%s: Send FPP_CMD_VOICE_BUFFER_UNLOAD\n", __func__);

	rc = fci_cmd(fci_handle, FPP_CMD_VOICE_BUFFER_UNLOAD, (u_int16_t *) &fpp_cmd, sizeof(fpp_cmd), res_buf, res_len);
	if (rc == 0 && res_buf[0] == FPP_ERR_OK)
	{
	close(voice_file_fd[cmd->file_id]);
	voice_file_fd[cmd->file_id] = 0;

	}
	else
	{
	if (rc < 0)
	cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_UNLOAD failed, '%s'\n", __func__, strerror(errno));
	else
	cmm_print(DEBUG_ERROR, "%s: FPP_CMD_VOICE_BUFFER_UNLOAD failed, %d\n", __func__, res_buf[0]);
	goto err;
	}

	err:
	return rc;
	}

	int voice_buffer_reset(FCI_CLIENT *fci_handle)
	{
	int rc;
	int i;

	rc = fci_write(fci_handle, FPP_CMD_VOICE_BUFFER_RESET, 0, NULL);

	for (i = 0; i < VOICE_FILE_MAX;i++)
	if (voice_file_fd[i])
	{
	close(voice_file_fd[i]);
	voice_file_fd[i] = 0;
	}

	return rc;
	}

	static void voice_buffer_set_usage(void)
	{
	cmm_print(DEBUG_STDOUT,
	"Usage: set voicebuf \n"
	"\n"
	" [load] <file_id> <payload_type> <frame_size> <filename>\n"
	"\n"
	" [unload] <file_id>\n"
	"\n"
	" [start] <socket_id> <buffer_id> <seq_number_base> <ssrc> <timestamp_base>\n"
	"\n"
	" [stop] <socket_id>\n"
	);
	}


	/* CMM client side voicebuf control */
	int cmmVoiceBufSetProcess(int argc, char *argv[], daemon_handle_t daemon_handle)
	{
	char buf[CMM_BUF_SIZE];
	int i = 0;
	int rc;
	const char* cmd_str = NULL;

	if (argc < 1)
	{
	fprintf(stderr, "%s: missing arguments for voicebuf command\n", __func__);
	goto err;
	}

	if (!strncasecmp(argv[i], "load", 4))
	{
	cmmd_voice_file_load_cmd_t cmd;

	if (argc < 5)
	{
	fprintf(stderr, "%s: missing arguments for voicebuf load command\n", __func__);
	goto err;
	}

	i++;
	cmd.file_id = strtoul(argv[i], NULL, 0);

	i++;
	cmd.payload_type = strtoul(argv[i], NULL, 0);

	i++;
	cmd.frame_size = strtoul(argv[i], NULL, 0);

	i++;
	strncpy(cmd.filename, argv[i], CMMD_VOICE_FILE_MAX_NAMESIZE);

	rc = cmmSendToDaemon(daemon_handle, CMMD_CMD_VOICE_FILE_LOAD, &cmd, sizeof(cmd), buf);
	cmd_str = "CMD_VOICE_FILE_LOAD";
	}
	else if (!strncasecmp(argv[i], "unload", 6))
	{
	cmmd_voice_file_unload_cmd_t cmd;

	if (argc < 2)
	{
	fprintf(stderr, "%s: missing arguments for voicebuf unload command\n", __func__);
	goto err;
	}

	i++;
	cmd.file_id = strtoul(argv[i], NULL, 0);

	rc = cmmSendToDaemon(daemon_handle, CMMD_CMD_VOICE_FILE_UNLOAD, &cmd, sizeof(cmd), buf);
	cmd_str = "CMD_VOICE_FILE_UNLOAD";
	}
	else if (!strncasecmp(argv[i], "start", 5))
	{
	fpp_voice_buffer_start_cmd_t cmd;

	if (argc < 6)
	{
	fprintf(stderr, "%s: missing arguments for voicebuf start command\n", __func__);
	goto err;
	}

	i++;
	cmd.socket_id = strtoul(argv[i], NULL, 0);

	i++;
	cmd.buffer_id = strtoul(argv[i], NULL, 0);

	i++;
	cmd.seq_number_base = strtoul(argv[i], NULL, 0);

	i++;
	cmd.ssrc = strtoul(argv[i], NULL, 0);

	i++;
	cmd.timestamp_base = strtoul(argv[i], NULL, 0);

	rc = cmmSendToDaemon(daemon_handle, FPP_CMD_VOICE_BUFFER_START, &cmd, sizeof(cmd), buf);
	cmd_str = "CMD_VOICE_BUFFER_START";
	}
	else if (!strncasecmp(argv[i], "stop", 4))
	{
	fpp_voice_buffer_stop_cmd_t cmd;

	if (argc < 2)
	{
	fprintf(stderr, "%s: missing arguments for voicebuf stop command\n", __func__);
	goto err;
	}

	i++;
	cmd.socket_id = strtoul(argv[i], NULL, 0);

	rc = cmmSendToDaemon(daemon_handle, FPP_CMD_VOICE_BUFFER_STOP, &cmd, sizeof(cmd), buf);
	cmd_str = "CMD_VOICE_BUFFER_STOP";
	}
	else
	goto err;

	if (rc == 2)
	{
	if (((u_int16_t*)buf)[0] != CMMD_ERR_OK)
	{
	fprintf(stdout, "%s: error sending %s: %d\n", __func__, cmd_str, ((u_int16_t*)buf)[0]);
	return -1;
	}
	}
	else
	{
	if (rc > 0)
	fprintf(stdout, "%s: unexpected response size received for %s: %d\n", __func__, cmd_str, rc);
	else
	fprintf(stdout, "%s: error sending %s: '%s'\n", __func__, cmd_str, strerror(errno));
	return -1;
	}

	return 0;

	err:
	/* print usage */
	voice_buffer_set_usage();

	return -1;
	}