#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>


#include "JZsdkLib.h"
#include "../../Megaphone.h"
#include "version_choose.h"
#include "AudioDeal/AudioDeal.h"
#include "AudioDeal/NoiseReduction/NoiseReduction.h"

#include "opus.h" 

#define WIDGET_SPEAKER_AUDIO_OPUS_MAX_FRAME_SIZE     (6 * 960)
static int RealTimeDecodeRate = 0; 
#define WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS           (1)

OpusDecoder *Opus_RealTimeVoice_decoder;
static int ReadTimeVoice_StatusFlag = JZ_FLAGCODE_OFF; //实时喊话是否有打开
static int Opus_RealTimeRecvLenth = 0;

//解码与播放
static unsigned char Opus_RealTimeVoice_Loop_Data[ (256 + 1) ][80];//解码缓存池 
static int Opus_RealTimeVoice_Loop_Head	=	0;				//池数头
static int Opus_RealTimeVoice_Loop_End	=	0;				//池数尾
static int Opus_RealTimeVoice_LoopReadFlag=0;//读取标志位0为停止，1为开始
static int Opus_RealTimeVoice_LoopReadStopFlag = 0;
static int decode_error_count = 0; //解码错误计数

static T_JZsdkReturnCode Opus_RealTimeVoice_DecodeAndPlay_init();
static T_JZsdkReturnCode Opus_RealTimeVoice_ClearLoop();
static void *Opus_RealTimeVoice_LoopPlay(void *arg);
static T_JZsdkReturnCode Opus_RealTimeVoice_PlayLoop_HeadReset();

//写入数据部分
#define WRTTE_MAX_DATA_GROUP 15
static unsigned char Opus_RealTimeVoice_WriteDataLoop[ (WRTTE_MAX_DATA_GROUP + 1) ][80];//写入缓存池 最高同时存WRTTE_MAX_DATA_GROUP组数据 用于写入缓冲
static int Opus_RealTimeVoice_WriteData_LoopHead	=	0;				//池数头
static int Opus_RealTimeVoice_WriteData_LoopEnd	=	0;				//池数尾
static int Opus_RealTimeVoice_WriteData_ResidueLenth; // 写入缓存池池子残余物长度
static int Opus_RealTimeVoice_WriteDataFlag=0;//读取标志位0为停止，1为开始
static int Opus_RealTimeVoice_WriteDataStopFlag = 0;

static pthread_mutex_t WriteDataLock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t WriteCond = PTHREAD_COND_INITIALIZER;
int WriteDataFlag = 0;

static T_JZsdkReturnCode Opus_RealTimeVoice_WriteData_init();
static T_JZsdkReturnCode Opus_RealTimeVoice_WriteDataClear();
static void *Opus_RealTimeVoice_WriteData_Task(void *arg);
static T_JZsdkReturnCode Opus_RealTimeVoice_DeinitDecoder();

static T_JZsdkReturnCode Opus_RealTimeVoice_WriteDataHeadReset();

/**********************
 * 
 *  解码器注册
 * 
 * 
 * *****************/
static T_JZsdkReturnCode Opus_RealTimeVoiceInit(int decode_rate)
{
	T_JZsdkReturnCode ret;
	
	//1、开始实时喊话模式
	ReadTimeVoice_StatusFlag = JZ_FLAGCODE_ON; 
	RealTimeDecodeRate = decode_rate;

	//2、创建线程输入缓冲池线程
	ret = Opus_RealTimeVoice_WriteData_init();
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		return ret;
	}
	
	//3、创建解码线程
	ret = Opus_RealTimeVoice_DecodeAndPlay_init();
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		return ret;
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**************************
 * 
 *  实时喊话初始化
 * 
 * ***************************/
T_JZsdkReturnCode Opus_RealTimeVoice_Start(int decode_rate)
{
	T_JZsdkReturnCode ret;

	//打开标志位
	Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_ON);
    Megaphone_MegDataGenFinshFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_ON);

    //3、开启功放
    int amplifier = JZ_FLAGCODE_ON;
    Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);

	ret = Opus_RealTimeVoiceInit(decode_rate);
	if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
	{
		JZSDK_LOG_ERROR("实时喊话初始化失败");

		ReadTimeVoice_StatusFlag = JZ_FLAGCODE_OFF;
		Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);
		Megaphone_MegDataGenFinshFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);

		amplifier = JZ_FLAGCODE_OFF;
		Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);

		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;	
	}

    JZSDK_LOG_INFO("实时喊话初始化成功");
	Opus_RealTimeRecvLenth = 0;

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

}


/************************************************************************************************************************************************
 * 
 *      解码播放部分
 * 
 * 
*************************************************************************************************************************************************/
static T_JZsdkReturnCode Opus_RealTimeVoice_DecodeAndPlay_init()
{
    int err;
	//创建opus解码器
	Opus_RealTimeVoice_decoder = opus_decoder_create(RealTimeDecodeRate, WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS, &err);
    if (err < 0) {
        JZSDK_LOG_ERROR("实时喊话器解码器创建失败");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	//清空播放数据缓冲区
	Opus_RealTimeVoice_ClearLoop();

	//创建循环播放线程
	pthread_t loop_play_task;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程分离属性
	int opus_Protection = pthread_create(&loop_play_task,&task_attribute,Opus_RealTimeVoice_LoopPlay,NULL);		//线程
	if(opus_Protection != 0)
	{
		JZSDK_LOG_ERROR("创建自动解码线程失败！");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//解码opus并播放
static T_JZsdkReturnCode Opus_RealTimeVoice_PlayData(unsigned char *data,int len)
{
	int i;
    char pcm_bytes[WIDGET_SPEAKER_AUDIO_OPUS_MAX_FRAME_SIZE * WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS * 2 ];
    int frame_size;
	opus_int16 out[WIDGET_SPEAKER_AUDIO_OPUS_MAX_FRAME_SIZE * WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS ];
	
	int decodeErrorFlag = JZ_FLAGCODE_OFF;

	//解码
	frame_size = opus_decode(Opus_RealTimeVoice_decoder, (const unsigned char *)data, len, out, WIDGET_SPEAKER_AUDIO_OPUS_MAX_FRAME_SIZE, 0);	
    if (frame_size < 0) 
	{
		decodeErrorFlag = JZ_FLAGCODE_ON;

		switch (frame_size)
		{
			case OPUS_BAD_ARG:
				JZSDK_LOG_ERROR("decoder failed: OPUS_BAD_ARG 一个或多个参数无效");
			break;

			case OPUS_BUFFER_TOO_SMALL:
				JZSDK_LOG_ERROR("decoder failed: OPUS_BUFFER_TOO_SMALL 输出缓冲区不足");
			break;

			case OPUS_INTERNAL_ERROR:
				JZSDK_LOG_ERROR("decoder failed: OPUS_INTERNAL_ERROR Opus内部错误");
			break;

			case OPUS_INVALID_PACKET:
				JZSDK_LOG_ERROR("decoder failed: OPUS_INVALID_PACKET 压缩数据损坏或无效");
			break;

			case OPUS_UNIMPLEMENTED:
				JZSDK_LOG_ERROR("decoder failed: OPUS_UNIMPLEMENTED 不支持的特性/模式");
			break;

			case OPUS_INVALID_STATE:
				JZSDK_LOG_ERROR("decoder failed: OPUS_INVALID_STATE 解码器处于无效状态");
			break;
			
			default:
				JZSDK_LOG_ERROR("decoder failed");
			break;
		}

		// 解码失败时生成静音数据
        memset(out, 0, sizeof(opus_int16) * WIDGET_SPEAKER_AUDIO_OPUS_MAX_FRAME_SIZE * WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS);
        frame_size = WIDGET_SPEAKER_AUDIO_OPUS_MAX_FRAME_SIZE;  
    }

	//转换		
	opus_int16 TempPcm[WIDGET_SPEAKER_AUDIO_OPUS_MAX_FRAME_SIZE * WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS];

	for (i = 0; i < WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS * frame_size; i++) 
	{		
		TempPcm[i] = out[i] & 0xFF | (out[i] >> 8) << 8;

#if SPECIAL_VERSION == SPECIAL_DAOTONG
        TempPcm[i] = PcmNoiseReduction(TempPcm[i]);			
#endif
		pcm_bytes[2 * i] =  TempPcm[i] & 0xFF;
		pcm_bytes[2 * i + 1] = (TempPcm[i] >> 8) & 0xFF;
    }

	AudioDeal_PcmDataInput(RealTimeDecodeRate, pcm_bytes, frame_size*2, 1);

	if (decodeErrorFlag == JZ_FLAGCODE_ON)
	{
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}
	
	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


static void *Opus_RealTimeVoice_LoopPlay(void *arg)
{
	Opus_RealTimeVoice_LoopReadFlag = JZ_FLAGCODE_ON;

	Opus_RealTimeVoice_LoopReadStopFlag = JZ_FLAGCODE_ON;
	T_JZsdkReturnCode ret;
	JZSDK_LOG_INFO("实施喊话，数据解码播放线程建立\n");

	//设立缓冲区域
	int range = 0;
	while (range < 10 && Opus_RealTimeVoice_LoopReadFlag != JZ_FLAGCODE_OFF)  // 40ms*10 =400ms
	{
		range = (Opus_RealTimeVoice_Loop_End-Opus_RealTimeVoice_Loop_Head);
		if (range < 0)
		{
			range = range;
		}
	}
	
	while(Opus_RealTimeVoice_LoopReadFlag != JZ_FLAGCODE_OFF)
	{

		if(Opus_RealTimeVoice_Loop_Head!=Opus_RealTimeVoice_Loop_End)
		{
			ret = Opus_RealTimeVoice_PlayData(Opus_RealTimeVoice_Loop_Data[Opus_RealTimeVoice_Loop_Head],80);
			Opus_RealTimeVoice_Loop_Head++;
			Opus_RealTimeVoice_PlayLoop_HeadReset(); //池满判断
			if(ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
			{
				// // 记录解码错误次数，超过阈值则重置解码器
				// if (++decode_error_count > 10) {
				// 	JZSDK_LOG_WARN("Too many decode errors, resetting decoder");
				// 	decode_error_count = 0;
				// }   


				// 后续改进建议，重新注册解码器的同时，不进行数据的清空

				break;
			}
		}
	}

	Opus_RealTimeVoice_LoopReadStopFlag = JZ_FLAGCODE_OFF;

	if (ReadTimeVoice_StatusFlag == JZ_FLAGCODE_OFF)
	{
		JZSDK_LOG_INFO("实时喊话关闭\n");
	}
	else
	{
		JZSDK_LOG_ERROR("实时喊话解码器出错");

		//释放解码器
		Opus_RealTimeVoice_DeinitDecoder();
		
		//重新开始解码播放流程
		Opus_RealTimeVoiceInit(RealTimeDecodeRate);
	}
}

// 池子头部到底了，重置池头
static T_JZsdkReturnCode Opus_RealTimeVoice_PlayLoop_HeadReset()
{
	if (Opus_RealTimeVoice_Loop_Head >= 256)
	{
		Opus_RealTimeVoice_Loop_Head = 0;
	}
}

/// 池子尾部到底了，重置池尾
static T_JZsdkReturnCode Opus_RealTimeVoice_PlayLoopEndReset()
{
	if (Opus_RealTimeVoice_Loop_End >= 256)
	{
		Opus_RealTimeVoice_Loop_End = 0;
	}
}

//清空缓存池
static T_JZsdkReturnCode Opus_RealTimeVoice_ClearLoop()
{
	Opus_RealTimeVoice_Loop_Head=0;
	Opus_RealTimeVoice_Loop_End=0;

	printf("清空播放缓冲池");
}
/************************************************************************************************************************************************
 * 
 *      写入缓冲池部分
 * 
 * 
*************************************************************************************************************************************************/
//写入数据部分初始化
static T_JZsdkReturnCode Opus_RealTimeVoice_WriteData_init()
{
	//清空写入数据池
	Opus_RealTimeVoice_WriteDataClear();

	pthread_t WriteDataTask;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程分离属性
	int opus_Protection = pthread_create(&WriteDataTask,&task_attribute,Opus_RealTimeVoice_WriteData_Task,NULL);		//线程
	if(opus_Protection != 0)
	{
		JZSDK_LOG_ERROR("创建输入缓冲池线程线程失败！");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//将输入缓冲池的数据放入播放缓冲池
static T_JZsdkReturnCode Opus_RealTimeVoice_Put_WriteData_In_PlayLoop()
{
	memcpy(Opus_RealTimeVoice_Loop_Data[Opus_RealTimeVoice_Loop_End], Opus_RealTimeVoice_WriteDataLoop[Opus_RealTimeVoice_WriteData_LoopHead],80);
	Opus_RealTimeVoice_Loop_End ++;
	Opus_RealTimeVoice_WriteData_LoopHead ++;

	Opus_RealTimeVoice_PlayLoopEndReset();
	Opus_RealTimeVoice_WriteDataHeadReset();
}

//输入缓冲池任务
static void *Opus_RealTimeVoice_WriteData_Task(void *arg)
{
	int ret;
	JZSDK_LOG_INFO("实施喊话，输入数据缓冲线程建立");
	Opus_RealTimeVoice_WriteDataFlag = JZ_FLAGCODE_ON;
	Opus_RealTimeVoice_WriteDataStopFlag = JZ_FLAGCODE_ON;
	
	while(Opus_RealTimeVoice_WriteDataFlag == JZ_FLAGCODE_ON)
	{
		pthread_mutex_lock(&WriteDataLock);

		if(Opus_RealTimeVoice_WriteData_LoopHead!=Opus_RealTimeVoice_WriteData_LoopEnd)
		{
			//将输入缓冲池的数据放入播放缓冲池
			Opus_RealTimeVoice_Put_WriteData_In_PlayLoop();
		}

		// 在写入数据后解锁
		WriteDataFlag = 1;
        pthread_cond_signal(&WriteCond);
        pthread_mutex_unlock(&WriteDataLock);
	}

	Opus_RealTimeVoice_WriteDataStopFlag = JZ_FLAGCODE_OFF;
}


//写入数据缓存池重置
static T_JZsdkReturnCode Opus_RealTimeVoice_WriteDataClear()
{
	Opus_RealTimeVoice_WriteData_LoopHead=0;
	Opus_RealTimeVoice_WriteData_LoopEnd=0;
	Opus_RealTimeVoice_WriteData_ResidueLenth = 0;

	printf("清除写入缓冲池\n");
}

// 写入池子头部到底了，重置池头
static T_JZsdkReturnCode Opus_RealTimeVoice_WriteDataHeadReset()
{
	if (Opus_RealTimeVoice_WriteData_LoopHead >= WRTTE_MAX_DATA_GROUP)
	{
		Opus_RealTimeVoice_WriteData_LoopHead = 0;
	}
}

//	写入池子尾部到底了，重置池尾
static T_JZsdkReturnCode Opus_RealTimeVoice_WriteDataEndReset()
{
	if (Opus_RealTimeVoice_WriteData_LoopEnd >= WRTTE_MAX_DATA_GROUP)
	{
		Opus_RealTimeVoice_WriteData_LoopEnd = 0;
	}
}

//写入数据进缓存池,以用于后续播放
T_JZsdkReturnCode Opus_RealTimeVoice_WriteDataToLoop(unsigned char *buf,int length)
{
	int temp_lenth = 0;  //临时长度

	//判断输入的数据长度是否正常
	if (length <= 0)
	{
		JZSDK_LOG_ERROR("输入进缓冲池的数据长度有误:%d",length);
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	if (ReadTimeVoice_StatusFlag != JZ_FLAGCODE_ON)
	{
		JZSDK_LOG_ERROR("实时喊话未开启");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}
	
	//写入处理
	//① 、检查池子当前组内有无剩余数据，如果池子当前组有剩  上次写入的语音数据， 接着往里面写入
	if (Opus_RealTimeVoice_WriteData_ResidueLenth > 0) //如果残留物有长度
	{
		//两种可能，第一种 再次写入完数据后，也不够一组80
		if (length + Opus_RealTimeVoice_WriteData_ResidueLenth < 80)
		{
			for (   ; temp_lenth < length ; Opus_RealTimeVoice_WriteData_ResidueLenth++)
			{
				Opus_RealTimeVoice_WriteDataLoop[Opus_RealTimeVoice_WriteData_LoopEnd][Opus_RealTimeVoice_WriteData_ResidueLenth] = buf [temp_lenth];
				temp_lenth ++;
			}		
			return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
		}
		//足够就是正常步骤
		else
		{
			// 在写入解码前加锁
			pthread_mutex_lock(&WriteDataLock);

			while (WriteDataFlag != 1)
			{
				pthread_cond_wait(&WriteCond, &WriteDataLock);
			}

			//数据进池，每组80数据
			for(  ; Opus_RealTimeVoice_WriteData_ResidueLenth < 80 ; Opus_RealTimeVoice_WriteData_ResidueLenth ++)
			{
				Opus_RealTimeVoice_WriteDataLoop[Opus_RealTimeVoice_WriteData_LoopEnd] [Opus_RealTimeVoice_WriteData_ResidueLenth] = buf [temp_lenth];
				temp_lenth ++;
			}
			Opus_RealTimeVoice_WriteData_LoopEnd+=1;    //池尾后移一组
			Opus_RealTimeVoice_WriteData_ResidueLenth = 0;       //残留物长度归0

			Opus_RealTimeVoice_WriteDataEndReset(); //池满判断

			// 在解码数据后解锁
			WriteDataFlag = 0;
			pthread_cond_signal(&WriteCond);
			pthread_mutex_unlock(&WriteDataLock);
		}	
	}

	//②、从新的组处理数据
	//待处理数据超过80长度时
	while( (length - temp_lenth) >= 80)
	{	
		// 在写入解码前加锁
        pthread_mutex_lock(&WriteDataLock);

		while (WriteDataFlag != 1)
        {
            pthread_cond_wait(&WriteCond, &WriteDataLock);
        }
		
		//数据进池，每组80数据
		//printf("往池子里的第%d号里写入数据\n",Opus_RealTimeVoice_WriteData_LoopEnd);
		
		for(int ucLen = 0 ; ucLen < 80 ; ucLen ++)
		{
			Opus_RealTimeVoice_WriteDataLoop[Opus_RealTimeVoice_WriteData_LoopEnd] [ucLen] = buf [temp_lenth];
			temp_lenth ++;
		}
		
		Opus_RealTimeVoice_WriteData_LoopEnd+=1;  //池尾后移一组
		Opus_RealTimeVoice_WriteDataEndReset(); //池满判断

		// 在解码数据后解锁
        WriteDataFlag = 0;
        pthread_cond_signal(&WriteCond);
        pthread_mutex_unlock(&WriteDataLock);
	}

	//③、如果长度还有剩，把数据存到池子内的新组，并记录残留物长度
	if( (length - temp_lenth) > 0)
	{
		for (   ; temp_lenth < length ; Opus_RealTimeVoice_WriteData_ResidueLenth++)
		{
			Opus_RealTimeVoice_WriteDataLoop[Opus_RealTimeVoice_WriteData_LoopEnd] [Opus_RealTimeVoice_WriteData_ResidueLenth] = buf [temp_lenth];
			temp_lenth ++;
		}	
	
	}

	Opus_RealTimeRecvLenth += length;
	JZSDK_LOG_DEBUG("opus实时传入,写入总长度为%d",Opus_RealTimeRecvLenth);

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/************************************************************************************************************************************************
 * 
 *      状态相关
 * 
 * 
*************************************************************************************************************************************************/

//释放解码器
static T_JZsdkReturnCode Opus_RealTimeVoice_DeinitDecoder()
{
	//1、关闭线程
	Opus_RealTimeVoice_LoopReadFlag=JZ_FLAGCODE_OFF;//关闭解码数据池自读
	while (Opus_RealTimeVoice_LoopReadStopFlag == JZ_FLAGCODE_ON)
	{
		delayMs(1);
	}

	JZSDK_LOG_DEBUG("自读池已关闭");
	
	Opus_RealTimeVoice_WriteDataFlag = JZ_FLAGCODE_OFF;//关闭写入数据池
	while (Opus_RealTimeVoice_WriteDataStopFlag == JZ_FLAGCODE_ON)
	{
		delayMs(1);
	}	
	
	JZSDK_LOG_DEBUG("自动线程关闭完毕\n");
	
	//2、清空数据池
	Opus_RealTimeVoice_ClearLoop();
	Opus_RealTimeVoice_WriteDataClear();

	//3、如果解码器不为空，释放解码器
	if (Opus_RealTimeVoice_decoder != NULL)
	{
		//释放掉解码器
		JZSDK_LOG_INFO("释放解码器完成");
		opus_decoder_destroy(Opus_RealTimeVoice_decoder);
		Opus_RealTimeVoice_decoder = NULL;
	}
	else
	{
		JZSDK_LOG_INFO("解码器为空");
	}

}

/********************
 * 
 *  获取实时喊话模式
 * 
 * **************/
T_JZsdkReturnCode Opus_RealTimeVoice_GetStatusFlag()
{
	return ReadTimeVoice_StatusFlag;
}


/**************************
 * 
 *  opus实时喊话关闭
 * 
 * ***************************/
T_JZsdkReturnCode Opus_RealTimeVoice_Close()
{
	JZSDK_LOG_DEBUG("开始关闭opus");

	if (ReadTimeVoice_StatusFlag != JZ_FLAGCODE_ON)
	{
		JZSDK_LOG_ERROR("实时喊话未开启");
		return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
	}

	ReadTimeVoice_StatusFlag = JZ_FLAGCODE_OFF;

	//释放解码器
	Opus_RealTimeVoice_DeinitDecoder();

	JZSDK_LOG_DEBUG("解码器释放完毕，一共播放了%d的数据", Opus_RealTimeRecvLenth);

	//产生标志位
	Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);
    Megaphone_MegDataGenFinshFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);

    int amplifier = JZ_FLAGCODE_OFF;
    Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &amplifier);

	//关闭音频库
	AudioDeal_StopDeal();

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}