Add toolchain and mbtk source
Change-Id: Ie12546301367ea59240bf23d5e184ad7e36e40b3
diff --git a/mbtk/mbtk_lib/src/mbtk_audio_alsa.c b/mbtk/mbtk_lib/src/mbtk_audio_alsa.c
new file mode 100755
index 0000000..405ceda
--- /dev/null
+++ b/mbtk/mbtk_lib/src/mbtk_audio_alsa.c
@@ -0,0 +1,826 @@
+/**
+ * \file mbtk_audio_alsa.c
+ * \brief A Documented file.
+ *
+ * Detailed description
+ * \Author: js.wang <js.wang@mobiletek.cn>
+ * \Version: 1.0.0
+ * \Date: 2020-09-21
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+
+#include "audio_if_types.h"
+#include "audio_if_ubus.h"
+#include "audio_if_parameter.h"
+#include "audio_if.h"
+#include "audio_if_api.h"
+#include <unistd.h>
+#include <sys/stat.h>
+#include "audio_if_audio_hw_mrvl.h"
+#include "audio_hw_mrvl.h"
+#include <cutils/str_parms.h>
+#include "vcm.h"
+#include "voice_control.h"
+#include "mbtk_audio.h"
+
+
+// #define DEBUG 1
+
+#ifdef DEBUG
+ #define mbtk_audio_log(...) printf(__VA_ARGS__)
+#else
+ #define mbtk_audio_log(...)
+#endif
+
+typedef int (*_play_callback)(int hdl, int result);
+
+#define FAILURE -1
+#define ID_RIFF 0x46464952
+#define ID_WAVE 0x45564157
+#define ID_FMT 0x20746d66
+#define ID_DATA 0x61746164
+#define FORMAT_PCM 1
+
+
+
+struct mopen_audio_t
+{
+ int device;
+ audio_hw_device_t *audio_ahw_dev_ubus;
+ struct audio_stream_in *stream_in;
+ struct audio_stream_out *stream_out;
+ int pcm_packet_size; //320:NB, 640:WB
+ int pipe_data;
+ int fd[2];
+ pthread_t pid;
+ mbtk_audio_state_enum state;
+ pthread_mutex_t _cond_mutex;
+ pthread_mutex_t _stream_mutex;
+ void *usrData;
+};
+struct record_cb_s
+{
+ mbtk_audio_record_cb_func _cb;
+ void *cb_data;
+};
+
+static struct mopen_audio_t *internal_hdl = NULL;
+
+
+int mbtk_wav_pcm16Le_check(int fd)
+{
+ printf("MBTK_wav_pcm16Le_check()----------strart5, fd:%d\n", fd);
+ struct wav_header hdr;
+
+ if (fd <= 0)
+ return -1;
+
+ if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr))
+ {
+ printf("\n%s: cannot read header\n", __FUNCTION__);
+ return -1;
+ }
+
+ printf("hdr.riff_id:%X, hdr.riff_fmt:%X, hdr.fmt_id:%X", hdr.riff_id, hdr.riff_fmt, hdr.fmt_id);
+
+ if ((hdr.riff_id != ID_RIFF)
+ || (hdr.riff_fmt != ID_WAVE)
+ || (hdr.fmt_id != ID_FMT))
+ {
+ printf("\n%s: is not a riff/wave file\n", __FUNCTION__);
+ return -1;
+ }
+
+ if ((hdr.audio_format != FORMAT_PCM) || (hdr.fmt_sz != 16)) {
+ printf("\n%s: is not pcm format\n", __FUNCTION__);
+ return -1;
+ }
+
+ if (hdr.bits_per_sample != 16) {
+ printf("\n%s: is not 16bit per sample\n", __FUNCTION__);
+ return -1;
+ }
+
+ printf("audio_format: %d,num_channels: %d,sample_rate: %d,byte_rate: %d,bits_per_sample: %d data_sz: %d\n",
+ hdr.audio_format, hdr.num_channels, hdr.sample_rate, hdr.byte_rate, hdr.bits_per_sample, hdr.data_sz);
+
+ return hdr.data_sz;
+}
+
+
+static void simulateOffhook(struct mopen_audio_t *aud_hdl, unsigned int onoff)
+{
+ unsigned int pcm_on;
+ unsigned int DTMFDetectiononoff;
+ unsigned int dialToneToOthersTones;
+ unsigned int dialTonesToOthersDialTones;
+ unsigned int dialVadDuration;
+
+ pcm_on = onoff;
+ //send the command of "AUDIOSTUB_PCMCTL"
+ aud_hdl->audio_ahw_dev_ubus->switch_pcm(aud_hdl->audio_ahw_dev_ubus, pcm_on);
+
+ DTMFDetectiononoff = onoff;
+ dialToneToOthersTones = 50;
+ dialTonesToOthersDialTones = 4;
+ dialVadDuration = 3;
+ //send the command of "AUDIOSTUB_DTMFDETECTIONCTL"
+ //vcm_DTMFDetection(1, 50, 4, 3);
+ vcm_DTMFDetection(DTMFDetectiononoff, dialToneToOthersTones, dialTonesToOthersDialTones, dialVadDuration);
+
+ return;
+}
+static int config_parameters(int in_out, int NBWB)
+{
+ unsigned int direction = 0xFF, type, srcdst, priority, dest;
+ char kvpair[128];
+ struct str_parms *param = NULL;
+ int data[5];
+ const char *key = NULL;
+ bool update_vcm = false;
+
+ direction = in_out;/* 0-play, 1-record */
+ type = NBWB; /* 0:PCM_NB_BUF_SIZE, 1:PCM_WB_BUF_SIZE */
+ srcdst = 1;/* 0-None, 1-Near end, 2-Far end, 3-Both ends */
+ priority = 1;/* 0-Do not combine(override), 1-Combine */
+ dest = 1;/* 0-Near codec, 1-Near Vocoder */
+
+ memset(kvpair, 0x00, sizeof(kvpair));
+ sprintf(kvpair, "%s=%d;%s=%d;%s=%d;%s=%d;%s=%d", VCM_CONFIG_DIRECTION, direction,
+ VCM_CONFIG_TYPE, type, VCM_CONFIG_SRC_DST, srcdst,
+ VCM_CONFIG_PRIORITY, priority, VCM_CONFIG_DEST, dest);
+
+ mbtk_audio_log("%s: config information kvpair is %s.\n", __FUNCTION__, kvpair);
+
+ //extract the parameter and config from string
+ param = str_parms_create_str(kvpair);
+ if (!param) {
+ printf("%s: param create str is null!", __FUNCTION__);
+ return -1;
+ }
+
+ //set vcm configurations
+ key = VCM_CONFIG_DIRECTION;
+ if (str_parms_get_int(param, key, &data[0]) == 0) {
+ update_vcm = true;
+ str_parms_del(param, key);
+ }
+ key = VCM_CONFIG_TYPE;
+ if (str_parms_get_int(param, key, &data[1]) == 0) {
+ update_vcm = true;
+ str_parms_del(param, key);
+ }
+ key = VCM_CONFIG_SRC_DST;
+ if (str_parms_get_int(param, key, &data[2]) == 0) {
+ update_vcm = true;
+ str_parms_del(param, key);
+ }
+ key = VCM_CONFIG_PRIORITY;
+ if (str_parms_get_int(param, key, &data[3]) == 0) {
+ update_vcm = true;
+ str_parms_del(param, key);
+ }
+ key = VCM_CONFIG_DEST;
+ if (str_parms_get_int(param, key, &data[4]) == 0) {
+ update_vcm = true;
+ str_parms_del(param, key);
+ }
+
+ //printf("Direction is %d, Type is %d, Src_Dst is %d, Priority is %d, Dest is %d. \n",data[0], data[1], data[2], data[3], data[4]);
+
+ if (update_vcm) {
+ configure_vcm(data); /*TODO check if all inputs got all values successfully*/
+ }
+
+ return 0;
+}
+
+void mbtk_audio_set_status(void* hdl, mbtk_audio_state_enum _status)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)hdl;
+ if (NULL == hdl || NULL == internal_hdl)
+ return 0;
+ pthread_mutex_lock(&pcxt->_cond_mutex);
+ pcxt->state = _status;
+ pthread_mutex_unlock(&pcxt->_cond_mutex);
+}
+
+static void* mbtk_record_pthread(void* hdl)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)hdl;
+ struct record_cb_s *_usrData = (struct record_cb_s *)pcxt->usrData;
+ unsigned bufsize = 0;
+ char *data = NULL;
+ int len;
+
+ if (NULL == hdl)
+ return NULL;
+
+ bufsize = pcxt->pcm_packet_size;
+ data = calloc(1, bufsize);
+ if (!data) {
+ fprintf(stderr, "\n%s:could not allocate %d bytes\n", __FUNCTION__, bufsize);
+ return NULL;
+ }
+
+ mbtk_audio_set_status(hdl, AUDIO_RUNNING);
+
+ while (pcxt->state != AUDIO_STOP)
+ {
+ len = pcxt->stream_in->read(pcxt->stream_in, data, bufsize);
+ if (len < 0) {
+ printf("%s: error reading!\n", __FUNCTION__);
+ break;
+ }
+ if ((bufsize > 0) && (NULL != _usrData->_cb))
+ {
+ _usrData->_cb(2, data, bufsize);
+ }
+ }
+ pcxt->pid = 0;
+ if(pcxt->usrData)
+ {
+ free(pcxt->usrData);
+ pcxt->usrData = NULL;
+ }
+ free(data);
+ mbtk_audio_log("pcm pthread end-\n");
+ return NULL;
+}
+
+static void* mbtk_play_pthread(void* hdl)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)hdl;
+ _play_callback audio_play_cb = (_play_callback)pcxt->usrData;
+ unsigned bufsize = 0;
+ char *data = NULL;
+ int first_set = 0;
+ int ret = 0;
+ int rc;
+
+ pthread_detach(pthread_self());
+ if (NULL == hdl)
+ return NULL;
+
+ bufsize = pcxt->pcm_packet_size;
+ data = calloc(1, bufsize);
+ if (!data) {
+ fprintf(stderr, "\n%s:could not allocate %d bytes\n",__FUNCTION__,bufsize);
+ pthread_exit(NULL);
+ }
+
+ while (pcxt->state != AUDIO_STOP && 0 != pcxt->pipe_data)
+ {
+ ret = read(pcxt->fd[0], data, bufsize);
+ // printf("%s:read : %d bytes\n", __FUNCTION__, ret);
+ if(ret == 0) {
+ mbtk_audio_log("%s %d [%d]", __FUNCTION__, __LINE__, ret);
+ continue;
+ }
+ if(ret < 0) {
+ mbtk_audio_log("%s %d [%d]", __FUNCTION__, __LINE__, ret);
+ break;
+ }
+ if ((0 == first_set || AUDIO_RESUME == pcxt->state))
+ {
+ first_set = 1;
+ mbtk_audio_set_status(hdl, AUDIO_RUNNING);
+ }
+
+ pthread_mutex_lock(&pcxt->_stream_mutex);
+ pcxt->pipe_data -= ret;
+ pthread_mutex_unlock(&pcxt->_stream_mutex);
+ if(pcxt->pipe_data < 0)
+ pcxt->pipe_data = 0;
+ if(ret < pcxt->pcm_packet_size)
+ printf("pcm %d - %d\n", pcxt->pipe_data, ret);
+
+ rc = pcxt->stream_out->write(pcxt->stream_out, data, ret);
+ if (rc < 0) {
+ printf("%s: error writing (child).\n", __FUNCTION__);
+ break;
+ } else if (rc < (signed int)pcxt->pcm_packet_size) {
+ printf("%s: wrote less than buffer size, rc=%d.\n", __FUNCTION__, rc);
+ break;
+ }
+ }
+
+ if (pcxt->fd[0] != 0 && pcxt->fd[1] != 0)
+ {
+ close(pcxt->fd[0]);
+ close(pcxt->fd[1]);
+ pcxt->fd[0] = 0;
+ pcxt->fd[1] = 0;
+ /* printf("close pcxt->fd!\n"); */
+ }
+ if (audio_play_cb)
+ audio_play_cb(pcxt, 5);
+ pcxt->pid = 0;
+// mbtk_audio_set_status(hdl, AUDIO_STOP);
+ mbtk_audio_set_status(hdl, AUDIO_OPEN);
+ free(data);
+ mbtk_audio_log("\n%s:exit!\n", __FUNCTION__);
+ pthread_exit(NULL);
+
+ return NULL;
+}
+
+static int audio_init_play_pthread(void* hdl)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)hdl;
+ _play_callback audio_play_cb = (_play_callback)pcxt->usrData;
+ int ret;
+
+ if (pcxt->fd[0] == 0 && pcxt->fd[1] == 0) {
+ if(pipe(pcxt->fd) == 0) {
+
+ pcxt->pipe_data = 0;
+ fcntl(pcxt->fd[0], F_SETFL, O_NONBLOCK);
+ fcntl(pcxt->fd[1], F_SETFL, O_NONBLOCK);
+ } else {
+ fprintf(stderr, "\n%d: create pipe error\n", __LINE__);
+ return -1;
+ }
+ }
+ if (pcxt->pid == 0) {
+ if (audio_play_cb)
+ audio_play_cb(pcxt, 0);
+ mbtk_audio_set_status(pcxt, AUDIO_RUNNING);
+ ret = pthread_create(&pcxt->pid, NULL, mbtk_play_pthread, hdl);
+ if (ret != 0)
+ {
+ fprintf(stderr, "\n%s: Failed create pthread\n",__FUNCTION__);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+int mbtk_audio_play_wait_end(void* hdl)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)hdl;
+
+ if (NULL == hdl)
+ {
+ fprintf(stderr, "\n%s: intput invalid params\n",__FUNCTION__);
+ return -1;
+ }
+
+ if(pcxt->pid != 0)
+ {
+ do{
+ usleep(10000);
+ }
+ while(pcxt->state != AUDIO_STOP);
+ pcxt->pid = 0;
+ }
+
+ return 0;
+}
+
+static int audio_open_pcm(void *dev_hdl, int num_channels, int rate, int in_out)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)dev_hdl;
+ int nb_wb;
+
+ //Support 8k/16k & mono wave file
+ if (((rate != 8000) && (rate != 16000))
+ || (num_channels != 1) ) {
+ printf("%s: error wave file:rate = %d, num_channels = %d!! \n",
+ __FUNCTION__,rate, num_channels);
+ return -1;
+ }
+
+ printf("%s: success open, rate = %d, num_channels = %d.\n",
+ __FUNCTION__, rate, num_channels);
+
+ if ((8000 == rate) && (1 == num_channels)) {
+ nb_wb = 0;//NB
+ pcxt->pcm_packet_size = PCM_NB_BUF_SIZE;
+ } else if ((16000 == rate) && (1 == num_channels)) {
+ nb_wb = 1;//WB
+ pcxt->pcm_packet_size = PCM_WB_BUF_SIZE;
+ }
+
+ //config playback parameters.
+ config_parameters(in_out, nb_wb);
+ pcxt->device = in_out;
+ return 0;
+}
+
+mbtk_audio_handle mbtk_audio_open(mbtk_audio_dev_enum dev, int flag, int rate, void *usrData)
+{
+ int value = 1;
+ struct mopen_audio_t *aud_hdl = NULL;
+ int ret;
+
+ // if (dev <= AUDIO_NULL || dev >= AUDIO_MAX)
+ // {
+ // printf("invaild PCM dev\n");
+ // return NULL;
+ // }
+ if(internal_hdl)
+ {
+ printf("Audio device inited\n");
+ return internal_hdl;
+ }
+ aud_hdl = (struct mopen_audio_t *) calloc(1, sizeof(struct mopen_audio_t));
+ if (!aud_hdl)
+ {
+ fprintf(stderr, "\n%s:Failed to allocate audio hdl!, errno=%d\n", __FUNCTION__, errno);
+ return NULL;
+ }
+ memset(aud_hdl, 0, sizeof(struct mopen_audio_t));
+
+ //init global variables
+ aud_hdl->audio_ahw_dev_ubus = audio_hal_install();
+ if (aud_hdl->audio_ahw_dev_ubus == NULL) {
+ printf("%s: audio_hal_install failed!\n", __FUNCTION__);
+ goto error;
+ }
+
+ if(1 == dev)
+ {
+ //send the command of "AUDIOSTUB_PCMCTL" and "AUDIOSTUB_DTMFDETECTIONCTL" to simulate telephone offhook.
+ // ASR Question #80497 Using it causes the recording to crash
+ // simulateOffhook(aud_hdl, 1);
+ //config playback parameters.
+ config_parameters(0, 0);
+ }
+ ret = audio_open_pcm(aud_hdl, flag, rate, dev);
+ if (ret)
+ {
+ printf("\n%s: pcm open error, errno=%d\n", __FUNCTION__, errno);
+ goto error;
+ }
+ if(1 == dev)
+ {
+ //open the audiostub_ctl, prepare for record and playback
+ VCMInit();
+ //open record stream
+ ret = aud_hdl->audio_ahw_dev_ubus->open_input_stream(aud_hdl->audio_ahw_dev_ubus, 0,
+ aud_hdl->audio_ahw_dev_ubus->get_supported_devices(aud_hdl->audio_ahw_dev_ubus),
+ NULL, &aud_hdl->stream_in, 0, 0, AUDIO_SOURCE_VOICE_CALL);
+ }
+ else
+ {
+ ret = aud_hdl->audio_ahw_dev_ubus->open_output_stream(aud_hdl->audio_ahw_dev_ubus, 0,
+ aud_hdl->audio_ahw_dev_ubus->get_supported_devices(aud_hdl->audio_ahw_dev_ubus),
+ AUDIO_OUTPUT_FLAG_DIRECT, NULL, &aud_hdl->stream_out, 0);
+ }
+
+ if (ret < 0) {
+ printf("%s: error opening output device. rc = %d\n", __FUNCTION__, ret);
+ goto error;
+ }
+ pthread_mutex_init(&aud_hdl->_cond_mutex, NULL);
+ pthread_mutex_init(&aud_hdl->_stream_mutex, NULL);
+ aud_hdl->usrData = usrData;
+ aud_hdl->state = AUDIO_OPEN;
+ /* printf("Mbtk_Audio_Open aud_hdl[%x][%x][%x]\n", aud_hdl, aud_hdl->_mixer_ctl, aud_hdl->_pcm); */
+ internal_hdl = aud_hdl;
+
+ return (void *)aud_hdl;
+
+error:
+ value = 0;
+ free(aud_hdl);
+ return NULL;
+}
+
+
+int mbtk_audio_play_stream_old(void *dev_hdl, const void *pData, int len)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)dev_hdl;
+
+ if (NULL == pcxt || NULL == internal_hdl)
+ return -1;
+
+ if (len > 1024) {
+ printf("audio play stream max size ( < 1024): %d\n", len);
+ return -2;
+ }
+
+ if (pcxt->state == AUDIO_STOP) {
+ return 0;
+ }
+ audio_init_play_pthread(pcxt);
+
+ pthread_mutex_lock(&pcxt->_stream_mutex);
+ pcxt->pipe_data += len;
+ pthread_mutex_unlock(&pcxt->_stream_mutex);
+ while(pcxt->state != AUDIO_STOP && (pcxt->pipe_data > 40960 || pcxt->fd[1] < 0 || pcxt->fd[1] == 0)) {
+ // printf("%s:wait %d %d\n", __FUNCTION__, pcxt->pipe_data, pcxt->fd[1]);
+ usleep(50000);
+ }
+
+ if(pcxt->fd[1] > 0) {
+ if (len != write(pcxt->fd[1], pData, len)) {
+ fprintf(stderr, "\n%s: pcm_write failed [%d %d]\n", __FUNCTION__, pcxt->fd[1], errno);
+ return -errno;
+ }
+ }
+
+ return 0;
+}
+
+int mbtk_audio_play_stream(void *dev_hdl, const void *pData, int len)
+{
+// printf("%s,--len:%d\n", __func__, len);
+ unsigned bufsize = 0;
+ char *data = NULL;
+ int first_set = 0;
+ int res = 0;
+ int ret = 0;
+ int read_size = 0;
+ char *p = (char *)pData;
+
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)dev_hdl;
+
+ if (NULL == dev_hdl || NULL == internal_hdl || pData == NULL)
+ return -1;
+
+ if(AUDIO_RUNNING == pcxt->state)
+ return -2;
+
+ bufsize = pcxt->pcm_packet_size;
+ data = calloc(1, bufsize);
+ if (!data) {
+ fprintf(stderr, "\n%s:could not allocate %d bytes\n",__FUNCTION__,bufsize);
+ pthread_exit(NULL);
+ }
+
+ mbtk_audio_set_status(dev_hdl, AUDIO_RUNNING);
+// if(bufsize > len )
+// {
+// bufsize = len;
+// }
+
+ while (pcxt->state != AUDIO_STOP)
+ {
+
+ memcpy(data,p+read_size, bufsize );
+ read_size += bufsize;
+
+ if(read_size > len)
+ {
+ // printf(">[%d]\n", read_size);
+ break;
+ }
+
+ while(AUDIO_PAUSE == pcxt->state)
+ {
+ usleep(80000);
+ }
+
+ if ((0 == first_set || AUDIO_RESUME == pcxt->state))
+ {
+ first_set = 1;
+ mbtk_audio_set_status(dev_hdl, AUDIO_RUNNING);
+ }
+
+ ret = pcxt->stream_out->write(pcxt->stream_out, data, bufsize);
+ if (ret < 0) {
+ printf("%s: error writing (child).\n", __FUNCTION__);
+ break;
+ } else if (ret < (signed int)pcxt->pcm_packet_size) {
+ printf("%s: wrote less than buffer size, rc=%d.\n", __FUNCTION__, ret);
+ break;
+ }
+
+ if(read_size == len)
+ {
+ // printf("=[%d]", read_size);
+ break;
+ }
+
+ }
+
+ mbtk_audio_set_status(dev_hdl, AUDIO_OPEN);
+ free(data);
+ return 0;
+
+}
+
+
+int mbtk_audio_play_file(void *dev_hdl, int file_fd, int offset)
+{
+ unsigned bufsize = 0;
+ char *data = NULL;
+ int first_set = 0;
+ int file_data_sz = 0;
+ int res = 0;
+ int ret;
+
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)dev_hdl;
+
+ if (NULL == dev_hdl || NULL == internal_hdl)
+ return -1;
+
+ if(AUDIO_RUNNING == pcxt->state)
+ return -2;
+
+ file_data_sz = mbtk_wav_pcm16Le_check(file_fd);
+
+ bufsize = pcxt->pcm_packet_size;
+ data = calloc(1, bufsize);
+ if (!data) {
+ fprintf(stderr, "\n%s:could not allocate %d bytes\n",__FUNCTION__,bufsize);
+ pthread_exit(NULL);
+ }
+ if(offset)
+ {
+ lseek(file_fd, offset, SEEK_SET);
+ }
+
+ mbtk_audio_set_status(dev_hdl, AUDIO_RUNNING);
+ int all_size = 0;
+
+ while (pcxt->state != AUDIO_STOP)
+ {
+ res = read(file_fd, data, bufsize);
+ // printf("%s:read : %d bytes\n", __FUNCTION__, res);
+ if(res == 0 || res < 0)
+ {
+ // printf("[%d]", res);
+ break;
+ }
+
+ all_size += res;
+ if (file_data_sz < all_size || file_data_sz == all_size) {
+ printf("aplay size :%d - %d\n", file_data_sz, all_size);
+ break;
+ }
+
+ while(AUDIO_PAUSE == pcxt->state)
+ {
+ usleep(80000);
+ }
+
+ if ((0 == first_set || AUDIO_RESUME == pcxt->state))
+ {
+ first_set = 1;
+ mbtk_audio_set_status(dev_hdl, AUDIO_RUNNING);
+ }
+
+ ret = pcxt->stream_out->write(pcxt->stream_out, data, res);
+ if (ret < 0) {
+ printf("%s: error writing (child).\n", __FUNCTION__);
+ break;
+ } else if (ret < (signed int)pcxt->pcm_packet_size) {
+ printf("%s: wrote less than buffer size, rc=%d.\n", __FUNCTION__, ret);
+ break;
+ }
+ }
+
+ mbtk_audio_set_status(dev_hdl, AUDIO_OPEN);
+ free(data);
+
+ return 0;
+}
+
+int mbtk_audio_record(void *dev_hdl, mbtk_audio_record_cb_func cb_func, void *cb_data)
+{
+ struct mopen_audio_t *pcxt = (struct mopen_audio_t *)dev_hdl;
+ int res = -1;
+ struct record_cb_s *_usrData = NULL;
+
+ if (NULL == pcxt || NULL == internal_hdl || NULL == cb_func)
+ return -1;
+
+ if(AUDIO_RUNNING == pcxt->state)
+ return -2;
+
+ _usrData = malloc(sizeof(struct record_cb_s));
+ _usrData->_cb = cb_func;
+ _usrData->cb_data = cb_data;
+ pcxt->usrData = (void *)_usrData;
+ res = pthread_create(&pcxt->pid, NULL, mbtk_record_pthread, dev_hdl);
+ if (res != 0)
+ {
+ if(pcxt->usrData)
+ {
+ free(pcxt->usrData);
+ pcxt->usrData = NULL;
+ }
+ fprintf(stderr, "\n%s: Failed to create pthread\n", __FUNCTION__);
+ }
+ // 防止重复录音
+ usleep(500);
+
+ return res;
+}
+
+int mbtk_audio_close(void *dev_hdl)
+{
+ printf("mbtk_audio_close()\n");
+ int value = 0;
+ struct mopen_audio_t *_hdl = (struct mopen_audio_t *)dev_hdl;
+
+ if (NULL == _hdl || NULL == internal_hdl )
+ {
+ printf("mbtk_audio_close() fail dev_hdl is NULL\n");
+ return -1;
+ }
+
+ mbtk_audio_set_status(_hdl, AUDIO_STOP);
+ if(0 == _hdl->device) {
+ while (_hdl->pid != 0) {
+ usleep(10000);
+ }
+
+ vcm_playback_drain(0);//wait for drain the AP audiostub queue.
+ usleep(80000);//delay 80ms until DSP play out its buffered data.
+ _hdl->stream_out->common.standby(&_hdl->stream_out->common);
+ _hdl->audio_ahw_dev_ubus->close_output_stream(_hdl->audio_ahw_dev_ubus, _hdl->stream_out);
+ } else {
+
+ while (_hdl->pid != 0) {
+ sleep(1);
+ }
+ _hdl->stream_in->common.standby(&_hdl->stream_in->common);
+ _hdl->audio_ahw_dev_ubus->close_input_stream(_hdl->audio_ahw_dev_ubus, _hdl->stream_in);
+ VCMDeinit();//close the fd of audiostub_ctl when exit the thread.
+ }
+
+ audio_hal_uninstall();
+ pthread_mutex_destroy(&_hdl->_cond_mutex);
+ pthread_mutex_destroy(&_hdl->_stream_mutex);
+ free(_hdl);
+ _hdl = NULL;
+ internal_hdl = NULL;
+
+ return 0;
+}
+
+int mbtk_audio_pause(void* dev_hdl)
+{
+ // struct pcm *_pcm = ((struct mopen_audio_t *)dev_hdl)->_pcm;
+
+ if (NULL == dev_hdl || NULL == internal_hdl)
+ return -1;
+
+ if (((struct mopen_audio_t *)dev_hdl)->state != AUDIO_RUNNING)
+ {
+ return -1;
+ }
+
+ // if (ioctl(_pcm->fd, SNDRV_PCM_IOCTL_PAUSE, 1))
+ // {
+ // printf("\n%s: cannot pause channel: errno =%d\n",__FUNCTION__,-errno);
+ // return -errno;
+ // }
+ mbtk_audio_set_status(dev_hdl, AUDIO_PAUSE);
+ return 0;
+}
+
+int mbtk_audio_resume(void* dev_hdl)
+{
+ if (NULL == dev_hdl || NULL == internal_hdl)
+ return -1;
+
+ if (((struct mopen_audio_t *)dev_hdl)->state != AUDIO_PAUSE)
+ {
+ return -1;
+ }
+
+ // if (ioctl(_pcm->fd, SNDRV_PCM_IOCTL_PAUSE, 0))
+ // {
+ // printf("\n%s: cannot Resume channel: errno =%d\n", __FUNCTION__, -errno);
+ // return -errno;
+ // }
+ mbtk_audio_set_status(dev_hdl, AUDIO_RESUME);
+ return 0;
+}
+
+int mbtk_audio_stop(void* dev_hdl)
+{
+ struct mopen_audio_t *_hdl = (struct mopen_audio_t *)dev_hdl;
+
+ if (NULL == dev_hdl || NULL == internal_hdl)
+ return -1;
+
+ // if (ioctl(_hdl->_pcm->fd, SNDRV_PCM_IOCTL_DROP))
+ // {
+ // printf("\n%s: cannot Resume channel: errno =%d\n",__FUNCTION__,-errno);
+ // return -errno;
+ // }
+
+ mbtk_audio_set_status(dev_hdl, AUDIO_STOP);
+ _hdl->pid = 0;
+
+ return 0;
+}
+
+mbtk_audio_state_enum mbtk_audio_state_get(void *hdl)
+{
+ return ((struct mopen_audio_t *)hdl)->state;
+}