aud_app.c_pdata=(u8t*)&code-CSDN博客

本文链接：https://blog.csdn.net/qq_14997637/article/details/83902512

#include "aud_app.h"
#include "crc_8.h"
#include "aud_media.h"
#include "aud_timer.h"




/*存放media数据的音频文件*/
 struct t_pcm_file g_pcm_file;
/*音频当前状态*/
 E_AUD_STATUS g_audio_status = STOP_STATUS;
/*录音当前状态*/
 E_RECORD_STATUS g_recocder_status = RECORDER_STOP_STATUS;
/*记录当前帧指针*/
 struct t_aud_frame* ptr_cur_aud_frame = NULL;
/*记录当前协议字段*/
 E_PROTOCOL_TYPE* g_protocol_type = NULL;


struct t_cmd_hander cmd_handler_mapping[] =
{
	/*录音*/
	{ START_RECORDER_REQ,start_recorder_req },           //启动录音请求
	{ STOP_RECORDER_REQ,stop_recorder_req },             //停止录音请求

													 /*音频*/
	{ START_PLAY_AUDIO_REQ,start_play_audio_req },  //音频play请求
	{ STOP_PLAY_AUDIO_REQ,stop_play_audio_req },    //音频stop请求
	{ AUDIO_DATA_IND,start_audio_media_rev }        //音频media传输
};

void aud_amp_poweron(void)
{
	//拉高gpio4
#if _AUD_DEBUG
	printf("aud_amp_poweron \r\n");
#endif
	pfv_OutputHigh(base_IO_GPIO4);
}


void aud_amp_poweroff(void)
{
#if _AUD_DEBUG
	printf("aud_amp_poweroff \r\n");
#endif
	pfv_OutputLow(base_IO_GPIO4);
}


int start_audio_app(sci_ESequence sciSeq, const void * ptr, u32 ulen)
{

		sci_timer_flash();
		return aud_protocol_parse(ptr, ulen);

}

int close_audio_app(sci_ESequence sciSeq, const void * ptr, u32 ulen)
{
	aud_amp_poweroff();
	return 0;
}




static BOOL protocol_receive_frame(E_PROTOCOL_TYPE* pp_type, struct t_aud_frame* pp_aud_frame, u8 vp_c)
{
	BOOL ret = FALSE;
	static BOOL fl_comple = TRUE;
	static u16 readcnt = 0;



	switch (*pp_type)
	{
	case PROTOCOL_HEAD:
#if _AUD_DEBUG
		printf("====================PROTOCOL_HEAD==============\r\n");
#endif
		fl_comple = TRUE; readcnt = 0;
		if (vp_c == PROTOCOL_HEAD_CODE)      //获取起始码
		{
			pp_aud_frame->m_Head = PROTOCOL_HEAD_CODE;
			(*pp_type) = PROTOCOL_CRC;
			timeout_tim(TRUE); //开启超时检测
		}
		
		break;
	case PROTOCOL_CRC:
		pp_aud_frame->m_Crc = vp_c;          //获取CRC校验码
		(*pp_type) = PROTOCOL_ID;
		break;
	case PROTOCOL_ID:
		pp_aud_frame->m_CmdId = vp_c;        //获取命令ID
		(*pp_type) = PROTOCOL_DLEN;
		break;

	case PROTOCOL_DLEN:                     //获取数据长度   LSB - MSB
		if (fl_comple == TRUE)
		{
			pp_aud_frame->m_DataLen = (vp_c & 0xff);
			fl_comple = FALSE;
		}else
		{
			pp_aud_frame->m_DataLen |= (vp_c << 8);
			fl_comple = TRUE;
			(*pp_type) = (pp_aud_frame->m_DataLen == 0) ? PROTOCOL_HEAD : PROTOCOL_DATA;
			ret = ((*pp_type) == PROTOCOL_HEAD) ? TRUE : FALSE;
		}
		break;
	case PROTOCOL_DATA:              //获取数据
		if (pp_aud_frame->m_Data == NULL) /*动态分配数据缓冲区，请务必释放 */
		{
#if _AUD_DEBUG
			printf("malloc mem size: %d Byte \r\n", pp_aud_frame->m_DataLen);
#endif
			pp_aud_frame->m_Data = (u8*)malloc(pp_aud_frame->m_DataLen * sizeof(u8));
		}	
		pp_aud_frame->m_Data[readcnt++] = vp_c;
		(*pp_type) = (readcnt == pp_aud_frame->m_DataLen) ? PROTOCOL_HEAD : PROTOCOL_DATA;
		readcnt = ((*pp_type) == PROTOCOL_HEAD) ? 0 : readcnt;
		ret = ((*pp_type) == PROTOCOL_HEAD) ? TRUE : FALSE;
		if (ret)                             //关闭超时检测
		{
			timeout_tim(FALSE);
		}

		break;
	default:
		break;
	}
	return ret;
}


u8 aud_get_crc8(struct t_aud_frame* pp_aud_frame)
{
	/*校验buf数据*/

	u8* p_data = (u8*)malloc(pp_aud_frame->m_DataLen + 3);
	memset(p_data, 0, pp_aud_frame->m_DataLen + 3);
	p_data[0] = pp_aud_frame->m_CmdId;
	memcpy((u8*)&p_data[1], (u8*)&(pp_aud_frame->m_DataLen), sizeof(u16));
	memcpy((u8*)&p_data[3], pp_aud_frame->m_Data, pp_aud_frame->m_DataLen);

	/*计算校验*/
	u8 crc = get_crc8(p_data, pp_aud_frame->m_DataLen + 3);
	free(p_data);
	return crc;
}

int aud_protocol_parse(const void* pp_ptr, u32 vp_ulen)
{
	u32 i = 0; 

	BOOL ret = FALSE;
	/*遍历buf 合成音频app协议帧*/
	static struct t_aud_frame aud_frame;
	/*保存当前接收帧指针*/
	if (ptr_cur_aud_frame == NULL)
		ptr_cur_aud_frame = &aud_frame;

	/*当前接收数据类型*/
	static E_PROTOCOL_TYPE _protocol_type = PROTOCOL_HEAD;
	/*保存当前协议字段指针*/
	if (g_protocol_type == NULL)
		g_protocol_type = &_protocol_type;

	for (i = 0; i < vp_ulen; i++)
	{
		
		ret = protocol_receive_frame(&_protocol_type, &aud_frame, ((u8*)pp_ptr)[i]);  //读取一帧
		if (ret == TRUE)   //成功读取一帧,判断CRC校验
		{	
	#if _AUD_DEBUG
			printf("audio_frame: \r\n");
			printf("         head: 0x%x\r\n", aud_frame.m_Head);
			printf("         crc: 0x%x\r\n", aud_frame.m_Crc);
			printf("         cmd: %d\r\n", aud_frame.m_CmdId);
			printf("         d_len: %d\r\n", aud_frame.m_DataLen);
			printf("         data: ");
			/*
			for (j = 0; j < aud_frame.m_DataLen; j++)
			{
				printf(" 0x%x ", aud_frame.m_Data[j]);
				if( (j +1) % 32 == 0) printf("\r\n");
			}
			*/
			printf("\r\n");
			printf("\r\n");
			printf("\r\n");
			printf("\r\n");
	#endif

			if (aud_get_crc8(&aud_frame) == aud_frame.m_Crc)
			{
	#if _AUD_DEBUG
				printf("crc match success.\r\n");
	#endif
				aud_frame.m_Valid = TRUE;
			}
			else
			{
	#if _AUD_DEBUG
				printf("crc match failed: getcrc = 0x%x, calcrc = 0x%x .\r\n", aud_frame.m_Crc, aud_get_crc8(&aud_frame));
	#endif
				aud_frame.m_Valid = FALSE;
				/*校验失败，返回无效数据应答。由于每个请求帧的应答格式都不一致，故需区别应答*/
				struct t_rsp_code rsp_code;
				switch (aud_frame.m_CmdId)
				{
				case START_RECORDER_REQ:
					rsp_code.m_ContextId = 0;
					rsp_code.m_PlayResult = ERR_INVAILD_DATA;
					protocol_send_frame(START_RECORDER_RSP, &rsp_code, RECORDER_TYPE_RSP);
					break;
				case STOP_RECORDER_REQ:
					rsp_code.m_ContextId = 0;
					rsp_code.m_PlayResult = ERR_INVAILD_DATA;
					protocol_send_frame(STOP_RECORDER_RSP, &rsp_code, STOP_REC_TYPE_RSP);
					break;
				case START_PLAY_AUDIO_REQ:
					rsp_code.m_ContextId = (aud_frame.m_Data[7]) | (aud_frame.m_Data[8] << 8) | (aud_frame.m_Data[9] << 16) | (aud_frame.m_Data[10] << 24);
					rsp_code.m_PlayResult = ERR_INVAILD_DATA;
					protocol_send_frame(START_PLAY_AUDIO_RSP, &rsp_code, AUD_TYPE_RSP);
					break;
				case STOP_PLAY_AUDIO_REQ: 
					rsp_code.m_ContextId = (aud_frame.m_Data[7]) | (aud_frame.m_Data[8] << 8) | (aud_frame.m_Data[9] << 16) | (aud_frame.m_Data[10] << 24);
					rsp_code.m_PlayResult = ERR_INVAILD_DATA;
					protocol_send_frame(STOP_PLAY_AUDIO_RSP, &rsp_code, AUD_TYPE_RSP);
					break;
				default:
					break;

				}

			}
			/*判断是否跳过该命令*/
			if (check_skip_cmd(aud_frame.m_CmdId) == FALSE)
			{
				ret = aud_protocol_excute(&aud_frame);   //执行帧
			}
			
			if (aud_frame.m_Data) // 执行完成后，释放内存
			{
				free(aud_frame.m_Data);
				aud_frame.m_Data = NULL;
	#if _AUD_DEBUG
				printf("free mem size: %d Byte \r\n", aud_frame.m_DataLen);
	#endif
			}
		}
	}

	return ret;
}

int aud_protocol_excute(struct t_aud_frame* pp_aud_frame)
{
	int index = 0;
	int ret = 0;
	/*判断帧有效性*/
	if (pp_aud_frame->m_Valid == FALSE)return 0;

	/*执行命令*/
	for (index; index < sizeof(cmd_handler_mapping) / sizeof(cmd_handler_mapping[0]); index++)
	{
		if (pp_aud_frame->m_CmdId == cmd_handler_mapping[index].m_CmdId)
		{
			ret = (cmd_handler_mapping[index].m_handler)(pp_aud_frame);
			break;
		}

	}
	return ret;
}

/*音频play请求*/
int  start_play_audio_req(struct t_aud_frame* pp_aud_frame)
{
	struct t_play_media_format play_media;
	u8* p_data = pp_aud_frame->m_Data;

	/*解析请求帧-获取请求media格式*/
	play_media.m_Format = (E_PCM_FORMAT)p_data[0];
	play_media.m_Volume = p_data[1];
	play_media.m_FileSize = (p_data[2]) | (p_data[3] << 8) | (p_data[4] << 16) | (p_data[5] << 24);
	play_media.m_Crc = p_data[6];
	play_media.m_ContextId = (p_data[7]) | (p_data[8] << 8) | (p_data[9] << 16) | (p_data[10] << 24);


#if _AUD_DEBUG
	printf("play_media: \r\n");
	printf("         m_Format: %d\r\n", play_media.m_Format);
	printf("         m_Volume: %d\r\n", play_media.m_Volume);
	printf("         m_FileSize: 0x%.8x\r\n", play_media.m_FileSize);
	printf("         m_Crc: %d\r\n", play_media.m_Crc);
	printf("         m_ContextId: 0x%.8x \r\n",play_media.m_ContextId);
#endif

	/*创建音频文件*/
	struct t_pcm_file pcm_file = {0};
	pcm_file.m_filename = "audio_media";
	pcm_file.m_FileTotalSize = play_media.m_FileSize;
	pcm_file.m_Crc = play_media.m_Crc;
	pcm_file.m_MediaId = play_media.m_ContextId;
	pcm_file.m_Format = (E_PCM_FORMAT)play_media.m_Format;


	/*保存文件属性*/
	int pcm_ret = pcmfile_create(&pcm_file, (E_PCM_FORMAT)play_media.m_Format);
	if (pcm_ret >= 0)
	{
		memset(&g_pcm_file,0,sizeof(struct t_pcm_file));
		memcpy(&g_pcm_file, &pcm_file, sizeof(struct t_pcm_file));
	}

#if _AUD_DEBUG
	printf("pcm_file: \r\n");
	printf("         filename: %s\r\n", pcm_file.m_filename);
	printf("         fp: %p\r\n", pcm_file.m_fp);
	printf("         m_Format: %d \r\n", pcm_file.m_Format);
	printf("         m_FileSize: %u Byte\r\n", pcm_file.m_FileSize);
	printf("         mFileTotalSize: %u Byte\r\n", pcm_file.m_FileTotalSize);
	printf("         m_Crc: %d\r\n", pcm_file.m_Crc);
	printf("         mMediaId: 0x%.8x\r\n", pcm_file.m_MediaId);

#endif

	/*应答请求帧*/
	struct t_rsp_code     play_rsp_code;
	if (g_audio_status == STOP_STATUS)
	{
		if (pcm_ret < 0)
		{
			play_rsp_code.m_PlayResult = ERR_RES_OVER;
#if _AUD_DEBUG
			printf("creat the media file is failed..........\r\n");
#endif
		}
		else
		{
			play_rsp_code.m_PlayResult = RET_OK;
			g_audio_status = TRANS_STATUS;
#if _AUD_DEBUG
			printf("enter media data trans..........\r\n");
#endif
		}

	}

	else
	{
		play_rsp_code.m_PlayResult = ERR_BUSY;
		/*释放资源*/
		g_audio_status = STOP_STATUS;
		if (g_pcm_file.m_fp)
			fclose(g_pcm_file.m_fp);
		if (g_pcm_file.m_filename)
			remove(g_pcm_file.m_filename);
		memset(&g_pcm_file, 0, sizeof(struct t_pcm_file));
	}

	play_rsp_code.m_ContextId = play_media.m_ContextId;

	return protocol_send_frame(START_PLAY_AUDIO_RSP, &play_rsp_code, AUD_TYPE_RSP);
}

/*回馈应答*/
int protocol_send_frame(u8 vp_CmdId, struct t_rsp_code* pp_rspcode,E_TYPE_RSP vp_type_rsp)
{
	/*应答请求*/
	struct t_aud_frame    rsp_aud_frame;
	u8 rsq_buf[64] = { 0 };
	u8 rsq_size = 0;
	rsp_aud_frame.m_Head = PROTOCOL_HEAD_CODE;
	rsp_aud_frame.m_CmdId = vp_CmdId;
	rsp_aud_frame.m_DataLen = (vp_type_rsp == AUD_TYPE_RSP) ? sizeof(struct t_rsp_code) :(sizeof(pp_rspcode->m_PlayResult));
	rsp_aud_frame.m_Data = (u8*)pp_rspcode;
	rsp_aud_frame.m_Crc = aud_get_crc8(&rsp_aud_frame);

	memcpy(rsq_buf, (u8*)&rsp_aud_frame, (u32)&(((struct t_aud_frame*)0)->m_DataLen));     //拷贝应答头

	switch (vp_type_rsp)
	{
	case AUD_TYPE_RSP:
		//拷贝数据长度   LSb-MSB
		rsq_buf[3] = (rsp_aud_frame.m_DataLen) & 0xff;         rsq_buf[4] = (rsp_aud_frame.m_DataLen >> 8) & 0xff;
		//拷贝应答码
		rsq_buf[5] = pp_rspcode->m_PlayResult & 0xff;             rsq_buf[6] = (pp_rspcode->m_PlayResult >> 8) & 0xff;
		rsq_buf[7] = (pp_rspcode->m_PlayResult >> 16) & 0xff;     rsq_buf[8] = (pp_rspcode->m_PlayResult >> 24) & 0xff;
		//拷贝上下文ID
		rsq_buf[9] = pp_rspcode->m_ContextId & 0xff;              rsq_buf[10] = (pp_rspcode->m_ContextId >> 8) & 0xff;
		rsq_buf[11] = (pp_rspcode->m_ContextId >> 16) & 0xff;     rsq_buf[12] = (pp_rspcode->m_ContextId >> 24) & 0xff;
		rsq_size = 13;
		break;

	case RECORDER_TYPE_RSP:
		//拷贝数据长度   LSb-MSB
		rsq_buf[3] = (rsp_aud_frame.m_DataLen) & 0xff;         rsq_buf[4] = (rsp_aud_frame.m_DataLen >> 8) & 0xff;
		//拷贝应答码
		rsq_buf[5] = pp_rspcode->m_PlayResult & 0xff;             rsq_buf[6] = (pp_rspcode->m_PlayResult >> 8) & 0xff;
		rsq_buf[7] = (pp_rspcode->m_PlayResult >> 16) & 0xff;     rsq_buf[8] = (pp_rspcode->m_PlayResult >> 24) & 0xff;
		rsq_size = 9;
		break;

	case STOP_REC_TYPE_RSP:
		rsq_buf[3] = 0;  rsq_buf[4] = 0;
		rsq_size = 5;
		break;
	default:
		break;
	}

#if _AUD_DEBUG
	printf("rsp_frame: \r\n");
	printf("         head: 0x%x\r\n", rsp_aud_frame.m_Head);
	printf("         crc: %d\r\n", rsp_aud_frame.m_Crc);
	printf("         cmd: %d\r\n", rsp_aud_frame.m_CmdId);
	printf("         d_len: %d\r\n", rsp_aud_frame.m_DataLen);
	printf("         data:  \r\n");
	printf("             result:%d\r\n", *((int*)rsp_aud_frame.m_Data));
	printf("             contextid:0x%.8x\r\n", *((int*)(rsp_aud_frame.m_Data+4)));
	printf("\r\n");
	printf("\r\n");
	printf("send rsq: \r\n");
	printf("         data:  \r\n");
	for (int i = 0; i < rsq_size; i++)
	{
		printf(" 0x%x ", rsq_buf[i]);
	}
	printf("\r\n");
	printf("\r\n");
#endif
	return pfv_sci_SendData(USE_AUDIO_SCI,&rsq_buf, rsq_size);

}


/*音频media接收*/
int start_audio_media_rev(struct t_aud_frame* pp_aud_frame)
{
	struct t_rsp_code     rev_rsp_code;


	if (g_audio_status != TRANS_STATUS) return 0;

	int retsize = fwrite(pp_aud_frame->m_Data, 1, pp_aud_frame->m_DataLen, g_pcm_file.m_fp);
	g_pcm_file.m_FileSize += retsize;

#if _AUD_DEBUG
	printf("write media file  WriteSize = %dByte, FileSize = %dByte\r\n", retsize, g_pcm_file.m_FileSize);
#endif

	/*数据接收完成*/
	if (g_pcm_file.m_FileSize >= g_pcm_file.m_FileTotalSize)
	{
#if _AUD_DEBUG
		printf("tran the media data is comolete. TotalSize = %dByte, RevSize = %dByte\r\n", g_pcm_file.m_FileTotalSize, g_pcm_file.m_FileSize);
#endif



		/*进行音频数据校验*/
		int _crc_offset = 0;
		switch (g_pcm_file.m_Format)
		{
		case AMR_FMT:
			_crc_offset = sizeof(struct amr_header);
			break;
		case PCM_FMT:
			_crc_offset = sizeof(struct wav_header) - sizeof(2 * sizeof(u32));
			break;
		default:
			_crc_offset = -1;
			break;
		}

		if(_crc_offset >= 0)
		{
			u8 file_crc = file_crc8(g_pcm_file.m_fp, _crc_offset);
			if (g_pcm_file.m_Crc == file_crc && _crc_offset)
			{
#if _AUD_DEBUG
				printf("media file crc match is success.\r\n");
#endif
				/*应答接收数据成功*/
				rev_rsp_code.m_PlayResult = RET_OK;
				rev_rsp_code.m_ContextId = g_pcm_file.m_MediaId;
				protocol_send_frame(AUDIO_DATA_OVER_RSP, &rev_rsp_code, AUD_TYPE_RSP);


				start_play_media(&g_pcm_file);
				return 0;
			}
		}

#if _AUD_DEBUG
		printf("media file crc match is failed. getfileCrc = 0x%x. CalfileCrc = 0x%x.\r\n", g_pcm_file.m_Crc, file_crc8(g_pcm_file.m_fp, _crc_offset));
#endif
		/*应答接收数据错误*/
		rev_rsp_code.m_PlayResult = ERR_INVAILD_DATA;
		rev_rsp_code.m_ContextId = g_pcm_file.m_MediaId;
		protocol_send_frame(AUDIO_DATA_OVER_RSP, &rev_rsp_code, AUD_TYPE_RSP);

		/*释放资源*/
		g_audio_status = STOP_STATUS;
		if (g_pcm_file.m_fp)
			fclose(g_pcm_file.m_fp);
		if (g_pcm_file.m_filename)
			remove(g_pcm_file.m_filename);
		memset(&g_pcm_file, 0, sizeof(struct t_pcm_file));

	}
	return 0;
}

/*音频media播放*/
int start_play_media(struct t_pcm_file* pp_pcm_file)
{
	BOOL playret = TRUE;

	 skip_cmd_addItem(TRUE,15, STOP_PLAY_AUDIO_REQ);             //阻塞停止请求 1.5s
	//skip_cmd_addItem(TRUE, AUD_PLAYBLOCK, STOP_PLAY_AUDIO_REQ); //阻塞式播放

	/*开功放*/
	aud_amp_poweron();
	switch (pp_pcm_file->m_Format)
	{
	case AMR_FMT:
		playret = pfv_PlayAmrFile(pp_pcm_file->m_filename);
#if _AUD_DEBUG
		printf("play the amr media[%s]. ret = %d \r\n", pp_pcm_file->m_filename, playret);
#endif
		break;
	case PCM_FMT:
		playret = pfv_PlayPcmFile(pp_pcm_file->m_filename, 1, 8000, 16);
#if _AUD_DEBUG
		printf("play the pcm media[%s]. ret = %d \r\n", pp_pcm_file->m_filename, playret);
#endif
		break;
	default:
		playret = FALSE;
		break;
	}
	/*开启播放失败,直接返回播放结果应答*/
	if (playret == FALSE)
	{
		struct t_rsp_code     play_rsp_code;
		play_rsp_code.m_PlayResult = (g_audio_status == PLAY_STATUS) ? RET_OK : ERR_INVAILD_OPERATE;
		play_rsp_code.m_ContextId = g_pcm_file.m_MediaId;
		protocol_send_frame(AUDIO_PLAY_RSP, &play_rsp_code, AUD_TYPE_RSP);

		/*释放资源*/
		g_audio_status = STOP_STATUS;
		if (g_pcm_file.m_fp)            fclose(g_pcm_file.m_fp);
		if (g_pcm_file.m_filename)       remove(g_pcm_file.m_filename);
		memset(&g_pcm_file, 0, sizeof(struct t_pcm_file));

		/*关功放*/
		aud_amp_poweroff();
	}
	/*开启播放成功,播放结果回调函数处理*/
	else
	{
		g_audio_status = PLAY_STATUS;

	}
	return 0;
}

/*音频media停止*/
int  stop_play_audio_req(struct t_aud_frame* pp_aud_frame)
{
	
#if 0
/*阻塞当前方式*/
	if (g_audio_status == TRANS_STATUS || g_audio_status == PLAY_STATUS)
	{
		/*返回忙*/
		struct t_rsp_code     stop_rsp_code;
		stop_rsp_code.m_PlayResult = ERR_BUSY;
		stop_rsp_code.m_ContextId = g_pcm_file.m_MediaId;
		protocol_send_frame(STOP_PLAY_AUDIO_RSP, &stop_rsp_code, AUD_TYPE_RSP);
	}
	return 0;
#else
	/*直接抢占方式*/
	BOOL ret = 0;
	ret = pfv_StopAudioPlay();
	/*应答*/
	struct t_rsp_code     stop_rsp_code;
	stop_rsp_code.m_PlayResult = (ret == TRUE) ? RET_OK : ERR_INVAILD_DATA;
	stop_rsp_code.m_ContextId = g_pcm_file.m_MediaId;
	protocol_send_frame(STOP_PLAY_AUDIO_RSP, &stop_rsp_code, AUD_TYPE_RSP);

	/*释放资源*/
	if (g_audio_status == TRANS_STATUS || g_audio_status == PLAY_STATUS)
	{
		g_audio_status = STOP_STATUS;
		if(g_pcm_file.m_fp)
			fclose(g_pcm_file.m_fp);
		if (g_pcm_file.m_filename)
			remove(g_pcm_file.m_filename);
		memset(&g_pcm_file, 0, sizeof(struct t_pcm_file));
	}

	/*关功放*/
	aud_amp_poweroff();
	return 0;
#endif

}

/*音频播放结果回调*/
base_EEventResult pfv_aud_cb(base_EAudioKind vp_AudioKind, base_EAudioState vp_State)
{
	struct t_rsp_code     play_rsp_code;
	switch (vp_State)
	{
	case base_AUDIO_STATE_FINISH:
	case base_AUDIO_STATE_FAILED:

#if _AUD_DEBUG
		printf("audio play callback  vp_State = %d\r\n", vp_State);
#endif
		/*播放结果应答*/
	
		play_rsp_code.m_PlayResult = (g_audio_status == PLAY_STATUS) ? RET_OK : ERR_INVAILD_OPERATE;
		play_rsp_code.m_ContextId = g_pcm_file.m_MediaId;
		protocol_send_frame(AUDIO_PLAY_RSP, &play_rsp_code, AUD_TYPE_RSP);

		/*释放资源*/
		g_audio_status = STOP_STATUS;
		if (g_pcm_file.m_fp)            
			fclose(g_pcm_file.m_fp);
		if (g_pcm_file.m_filename)       
			remove(g_pcm_file.m_filename);
		memset(&g_pcm_file, 0, sizeof(struct t_pcm_file));
		aud_amp_poweroff();
		break;
	default:
		break;
	}
	/*关功放*/
	aud_amp_poweroff();
	return base_cbrOk;
}


/*开始录音请求*/
int start_recorder_req(struct t_aud_frame* pp_aud_frame)
{
	BOOL ret = FALSE;
	struct t_rsp_code     recorder_rsp_code;
	if (g_recocder_status != RECORDER_STOP_STATUS)
		recorder_rsp_code.m_PlayResult = ERR_BUSY;
	else
	{
		ret = pfv_StartRec(1, 8000, 16, "D9A");
#if _AUD_DEBUG
		printf("********************recorder  start.. ret = %d ********************\r\n", ret);
#endif
		recorder_rsp_code.m_PlayResult = (ret) ? RET_OK : ERR_INVAILD_OPERATE;
		/*启动录音失败，直接返回*/
		if(ret == FALSE)  
			g_recocder_status = RECORDER_STOP_STATUS;
		/*启动录音成功，进入录音模式，回调函数处理*/
		else              
			g_recocder_status = RECORDER_START_STATUS;
	}
		
	recorder_rsp_code.m_ContextId = 0;
	protocol_send_frame(START_RECORDER_RSP, &recorder_rsp_code, RECORDER_TYPE_RSP);
	return 0;
}
/*停止录音请求*/
int stop_recorder_req(struct t_aud_frame* pp_aud_frame)
{

	struct t_rsp_code recorder_rsp_code;
	/*已经处于停止录音模式，直接退出*/
	if (g_recocder_status != RECORDER_START_STATUS)
		return 0;

	/*停止录音*/
	recorder_rsp_code.m_PlayResult = (pfv_StopRec()) ? RET_OK : ERR_INVAILD_OPERATE;
	recorder_rsp_code.m_ContextId = 0;
	protocol_send_frame(STOP_RECORDER_RSP, &recorder_rsp_code, STOP_REC_TYPE_RSP);
	g_recocder_status = RECORDER_STOP_STATUS;


	return 0;
}

/*录音结果回调*/
base_EEventResult pfv_record_cb(const u8 *pp_Pcm_Data, u32 vp_DataLen, t_ywCbContext vp_Ctx)
{
	base_EEventResult ret = base_cbrOk;
	

	if (pp_Pcm_Data == NULL && vp_DataLen != 0)
	{
		return base_cbrError;
	}
	if (strcmp((char*)vp_Ctx, "D9A") == 0 && g_recocder_status == RECORDER_START_STATUS)
	{
		struct t_aud_frame rec_data_frame;
		rec_data_frame.m_Head = PROTOCOL_HEAD_CODE;
		rec_data_frame.m_CmdId = DATA_RECORDER_IND;
		rec_data_frame.m_DataLen = vp_DataLen;
		rec_data_frame.m_Data = (u8*)pp_Pcm_Data;
		rec_data_frame.m_Crc = aud_get_crc8(&rec_data_frame);

		/*申请发送buf*/
		u8* sendbuf = (u8*)malloc(rec_data_frame.m_DataLen + 5);
		sendbuf[0] = rec_data_frame.m_Head;
		sendbuf[1] = rec_data_frame.m_Crc;
		sendbuf[2] = rec_data_frame.m_CmdId;
		sendbuf[3] = rec_data_frame.m_DataLen & 0xff;
		sendbuf[4] = (rec_data_frame.m_DataLen >> 8) & 0xff;

		memcpy((u8*)&sendbuf[5], rec_data_frame.m_Data, rec_data_frame.m_DataLen);
		ret = (pfv_sci_SendData(USE_AUDIO_SCI,sendbuf, rec_data_frame.m_DataLen + 5) == 0) ? base_cbrOk : base_cbrError;

		/*释放发送buf*/
		free(sendbuf);
	}
	return ret;
}