#include <stdio.h>
#include <pthread.h>

#include "JZsdkLib.h"
#include "Hal_Send/HalSend.h"

#include "./Megaphone.h"
#include "UI_control/UI_control.h"
#include "AudioDeal/AudioDeal.h"
#include "Ircut/ircut.h"
#include "Megaphone/TTS/Espeak_tts/Espeak_tts.h"
#include "version_choose.h"
#include "DeviceInfo/DeviceInfo.h"
#include "BaseConfig.h"

#include "UI_control/Psdk_UI_io.h"
#include "JZsdk_Hal.h"

#include "Megaphone/MegTempControl/MegTempControl.h"
#include "./VolumeLimit.h"
#include "../AudioDeal/AudioDeal.h"
#include "./TTS/Megaphone_TTS.h"
#include "./TTS/cnTTS/cnTTS.h"
#include "Megaphone/Music/AudioFile/Megaphone_AudioFile.h"
#include "Megaphone/Music/RealTimeMP2/Megaphone_RealTimeMP2.h"
#include "Megaphone/opus/Megaphone_Opus.h"
#include "Megaphone/PcmAudio/PcmAudioFile.h"


int MegPlayStatusUnChange_flag = JZ_FLAGCODE_OFF;
static MegaphonePlayStatus g_Megaphone_Play_Status = AUDIO_PLAY_STATUS_IDLE;
static int g_Megaphone_Volume = 30;
static int g_Megaphone_RealTargetVolume = 30; //喊话器的实际目标音量
static int g_Megaphone_RealSetVolue = 30; //喊话器的实际音量

static int g_Megaphone_Loop = JZ_FLAGCODE_OFF; //循环播放
static int g_Megaphone_LoopInterval = 1000; //循环播放间隔 单位ms

static int MegDataGen_Flag = JZ_FLAGCODE_OFF; //用于记录喊话器的数据生产线程是否允许，以及提前关闭生产线程，播放前打开，播放后关闭
static int MegDataGenFinsh_Flag = JZ_FLAGCODE_OFF; //用于记录喊话器的数据生产线程是否已经完成，每次播放前都打开，每次播放结束后都关闭
int MegaphoneStatusFlag = JZ_FLAGCODE_OFF;  //标识喊话器是否已经初始化完毕

struct MegaphoneInfo *g_MegaphoneInfo = NULL;  //喊话器数据结构体

static T_JZsdkReturnCode Megaphone_ConvertPlayStatus(int status);
T_JZsdkReturnCode Megaphone_SetVolume(int value, int mode);//设置音量，音量0-100，默认音量value==10。

static int g_TTS_Max_volume = 0; //用于存储tts最大音量限制
static int g_Max_volume = 0; //用于存储最大音量限制

/**********************
 * 
 *  状态广播, 决定当前的播放状态是否需要广播
 *  并修改当前的喊话器状态
 *  每次开始播放 或者 结束播放都要进来
 * *********************/
static int LastAudioDealStatus = 0x00;
T_JZsdkReturnCode Megaphone_status_Broadcast(int status)
{
    //检查是否是提前中断音乐，必免提前中断的状态变化进行了广播
    if (MegPlayStatusUnChange_flag == JZ_FLAGCODE_ON)
    {
        MegPlayStatusUnChange_flag = JZ_FLAGCODE_OFF;

        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    g_Megaphone_Play_Status = status;
    int Broodcast = Megaphone_ConvertPlayStatus(status);

    //如果要广播空闲状态
    if (Broodcast == 0x00)
    {
        //确认音频库结束
        while (Get_AudioDealStatus() != JZ_FLAGCODE_OFF)
        {
            delayMs(1);
        }

        //状态没变
        if (LastAudioDealStatus == Broodcast)
        {
            return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
        }

        LastAudioDealStatus = 0x00;

        //广播播放结束
        JZSDK_LOG_INFO("广播播放结束");
        UIcontrol_Broadcast_PlayStatus_end();

        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    
    //广播播放状态
    if (Broodcast != LastAudioDealStatus)
    {
        LastAudioDealStatus = Broodcast;

        //广播播放状态
        JZSDK_LOG_INFO("广播播放：%d", LastAudioDealStatus);


    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/********************
 * 
 *  设置/获取 数据生产标志位
 * 
 * **************/
T_JZsdkReturnCode Megaphone_MegDataGenFlag(int order, int Flag)
{
    if (order == JZ_FLAGCODE_GET)
    {
        return MegDataGen_Flag;
    }
    
    MegDataGen_Flag = Flag;

    return MegDataGen_Flag;
}

/********************
 * 
 *  设置/获取 数据生产完成标志位
 * 
 * **************/
T_JZsdkReturnCode Megaphone_MegDataGenFinshFlag(int order, int Flag)
{
    if (order == JZ_FLAGCODE_GET)
    {
        return MegDataGenFinsh_Flag;
    }
    
    MegDataGenFinsh_Flag = Flag;

    return MegDataGenFinsh_Flag;
}


/*****************************
 * 
 *  音频播放函数
 * 
 * *****************************/
static T_JZsdkReturnCode Megaphone_Play(struct MegaphoneInfo *IndexInfo, enum MegaphonePlayStatus status, int ReplyFlag)
{
    T_JZsdkReturnCode ret;

    //1、查询当前是否处于实时语音模式，实时语音不能直接使用播放功能
    if ( Megaphone_RealTimeVoice_GetStatusFlag() == JZ_FLAGCODE_ON)
    {
        //是的话，无法进行操作
        JZSDK_LOG_ERROR("无法进行播放操作，目前正在进行实时语音播放");
        return JZ_ERRORCODE_REALTIMEVOICE_HAS_BEEN_ON;
    }

    //把暂停音乐的标志关了
    AudioDeal_PauseAndContinuePlay(JZ_FLAGCODE_OFF);

    //关闭音乐
    Megaphone_StopPlay(JZ_FLAGCODE_ON);

    switch (status)
    {
        case AUDIO_PLAY_STATUS_IFLAY_TTS:
        {
            JZSDK_LOG_INFO("音频播放:cnTTS");

            //播放讯飞tts
            ret = Megaphone_cnTTS_Play(IndexInfo->str, IndexInfo->str_len, ReplyFlag);
        }
        break;

        case ADDIO_PLAY_STATUS_ESPEAK_TTS:
        {
            JZSDK_LOG_INFO("音频播放:esTTS");

            ret = Espeak_tts(IndexInfo->str , IndexInfo->str_len);
        }
        break;

        case AUDIO_PLAY_STATUS_MUSIC:
        {
            JZSDK_LOG_INFO("音频播放：歌曲:%s",IndexInfo->str);

            //、音频播放
            ret = Megaphone_AudioFile_Play(IndexInfo->str, IndexInfo->str_len);
        }
        break;

        case AUDIO_PLAY_STATUS_OPUS_RECORD:
        {
            JZSDK_LOG_INFO("opus录音喊话");

            //opus播放
            ret = OpusFile_PlayFixedFile();
        }

        case AUDIO_PLAY_STATUS_PCM_LIST:
        {
            JZSDK_LOG_INFO("音频播放：pcm列表");

            //pcm播放
            ret = PcmAudioPlay_Play(IndexInfo->str, IndexInfo->str_len);
        }

        default:
            break;
    }

    return ret;
} 


/*************************
 * 
 *  音频库的数据停止函数
 *   歌曲播放属于音频库的功能，不在这里停止
 * 
 * ******************/
static T_JZsdkReturnCode Megaphone_DataGeneratorStop()
{
    //1、停止数据的产生函数
    Megaphone_MegDataGenFlag(JZ_FLAGCODE_SET, JZ_FLAGCODE_OFF);
    while (MegDataGenFinsh_Flag == JZ_FLAGCODE_ON) //等待上一次的数据产生函数结束
    {
        delayMs(1);
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;    
}



/********************************
 * 
 *  音频停止函数
 *  Unchangeflag 用于判断是否需要切换歌曲状态，歌且歌就是ON
 * 
 * ******************************/
T_JZsdkReturnCode Megaphone_StopPlay(int UnChangeFlag)
{
    //1、查询当前是否处于实时语音模式，实时语音不能直接用stopplay
    if ( Megaphone_RealTimeVoice_GetStatusFlag() == JZ_FLAGCODE_ON)
    {
        //是的话，无法进行操作
        JZSDK_LOG_ERROR("无法进行播放操作，目前正在进行实时语音播放");
        return JZ_ERRORCODE_REALTIMEVOICE_HAS_BEEN_ON;
    }

    if (g_Megaphone_Play_Status == AUDIO_PLAY_STATUS_IDLE)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    
    //切换式音乐暂停
    if (UnChangeFlag == JZ_FLAGCODE_ON)
    {
        MegPlayStatusUnChange_flag = JZ_FLAGCODE_ON;
    }

    JZSDK_LOG_INFO("执行停止音乐");

    //把暂停音乐的标志关了
    AudioDeal_PauseAndContinuePlay(JZ_FLAGCODE_OFF);

    //1、停止数据的产生函数
    Megaphone_DataGeneratorStop();

    //2、停止音频库里的处理部分
    AudioDeal_StopDeal();
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/**********************************************************************************************************************************
 * 
 *  TTS相关
 * 
 * 
 * 
 *********************************************************************************************************************************** /
/************************
 * 
 *  TTS播放
 * 
 * 
 * **********************/
T_JZsdkReturnCode Megaphone_TTS_Play(unsigned char *str, unsigned int str_len, int ReplyFlag)
{
    T_JZsdkReturnCode ret;

    memset(g_MegaphoneInfo, 0, sizeof(struct MegaphoneInfo));
    memcpy(g_MegaphoneInfo->str,str,str_len);
    g_MegaphoneInfo->str_len = str_len;

    //1、获取当前音色
    int tone = TTS_Get_tone();

    if (tone >= 0x00 && tone <= 0x36)
    {
        ret = Megaphone_Play(g_MegaphoneInfo, AUDIO_PLAY_STATUS_IFLAY_TTS, ReplyFlag);
    }
    else
    {
        ret = Megaphone_Play(g_MegaphoneInfo, ADDIO_PLAY_STATUS_ESPEAK_TTS, ReplyFlag);         
    }
    
    return ret;
}


/************************
 * 
 *  设置/获取 TTS的参数
 *  
 * 
 * **********************/
T_JZsdkReturnCode Megaphone_TTS_param(int flagcode, enum MegaphoneTTSParam paramflag, int *value)
{
    T_JZsdkReturnCode ret;

    if (flagcode == JZ_FLAGCODE_GET)
    {
        switch (paramflag)
        {
            case MEGAPHONE_TTS_NORMAL_VOLUME:
            {
                *value = TTS_Get_NormalVolume();
            }
            break;

            case MEGAPHONE_TTS_TONE:
            {
                *value = TTS_Get_tone();
            }
            break;

            case MEGAPHONE_TTS_SPEED:
            {
                *value = TTS_Get_speed();
            }
            break;

            case MEGAPHONE_TTS_APPEND_TONE:
            {
                *value = TTS_Get_TTS_AppendTone();
            }
            break;

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }
    
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else if (flagcode == JZ_FLAGCODE_SET)
    {
        switch (paramflag)
        {
            case MEGAPHONE_TTS_NORMAL_VOLUME:
            {
                TTS_Set_NormalVolume(*value);
            }
            break;

            case MEGAPHONE_TTS_TONE:
            {
                TTS_Set_tone(*value);
            }
            break;

            case MEGAPHONE_TTS_SPEED:
            {
                TTS_Set_speed(*value);
            }
            break;

            case MEGAPHONE_TTS_APPEND_TONE:
            {
                TTS_Set_TTS_AppendTone(*value);
            }
            break;

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }
    
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    JZSDK_LOG_ERROR("参数获取出错");
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}



/**********************************************************************************************************************************
 * 
 *  音频相关
 * 
 * 
 *********************************************************************************************************************************** /

 /*****************************
 * 
 *  播放音频
 * 
 * *****************************/
T_JZsdkReturnCode Megaphone_PlayAudioFile(unsigned char *name, unsigned int name_Len)
{
    if (name_Len > sizeof(g_MegaphoneInfo->str))
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    memset(g_MegaphoneInfo, 0, sizeof(struct MegaphoneInfo));
    memcpy(g_MegaphoneInfo->str,name,name_Len);
    g_MegaphoneInfo->str_len = name_Len;

    return Megaphone_Play(g_MegaphoneInfo, AUDIO_PLAY_STATUS_MUSIC, JZ_FLAGCODE_ON);
}


 /*****************************
 * 
 *  上一曲
 * 
 * *****************************/
T_JZsdkReturnCode Megaphone_PlayLastSong()
{
    T_JZsdkReturnCode ret; 
    unsigned char Filename[256];  
    int Filename_len;

    //获取上一首歌的名字
    ret = Megaphone_GetLastSongName(Filename, &Filename_len);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("获取上一首歌失败");
        return ret;
    }

    if (Filename_len > sizeof(g_MegaphoneInfo->str))
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    memset(g_MegaphoneInfo, 0, sizeof(struct MegaphoneInfo));
    memcpy(g_MegaphoneInfo->str,Filename,Filename_len);
    g_MegaphoneInfo->str_len = Filename_len;

    return Megaphone_Play(g_MegaphoneInfo, AUDIO_PLAY_STATUS_MUSIC, JZ_FLAGCODE_ON);
}

/*****************************
 * 
 *  下一曲
 * 
 * *****************************/
T_JZsdkReturnCode Megaphone_PlayNextSong()
{
    T_JZsdkReturnCode ret; 
    unsigned char Filename[256]; 
    int Filename_len;

    //获取下一首歌的名字
    ret = Megaphone_GetNextSongName(Filename, &Filename_len);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("获取下一首歌失败");
        return ret;
    }

    if (Filename_len > sizeof(g_MegaphoneInfo->str))
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    memset(g_MegaphoneInfo, 0, sizeof(struct MegaphoneInfo));
    memcpy(g_MegaphoneInfo->str,Filename,Filename_len);
    g_MegaphoneInfo->str_len = Filename_len;

    return Megaphone_Play(g_MegaphoneInfo, AUDIO_PLAY_STATUS_MUSIC, JZ_FLAGCODE_ON);
}

/************************
 * 
 *  刷新音频列表
 *  
 * 
 * **********************/
T_JZsdkReturnCode Megaphone_Flush_MusicList()
{
    //1、刷新列表
    AudioFile_FlushAudioList();

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



/************************
 * 
 *  获取音频总数
 *  
 * 
 * **********************/
T_JZsdkReturnCode Megaphone_get_music_list_sum(int *num)
{
    AudioMange_Get_FileNum(num);
    if (*num > 128)
    {
        *num = 128;
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



/************************
 * 
 *  获取音频名字
 *  
 * 
 * **********************/
T_JZsdkReturnCode Megaphone_get_music_list_name(int num,unsigned char *music_name, int *music_name_length)
{
    return Megaphone_AudioFile_GetAudioNameByIndex(num, music_name, music_name_length);
}


/************************
 * 
 *  获取当前音频名字
 *  
 * 
 * **********************/
T_JZsdkReturnCode Megaphone_get_play_FileName(unsigned char *music_name, int *music_name_length)
{
    return AudioMange_Get_FilePlayName(music_name, music_name_length, NULL);

}



/*********
 * 
 *  1、开始传输的音频文件保存
 * 
 * 
**********/
T_JZsdkReturnCode Megaphone_SaveAudioFileStart(char *FileName)
{
    return AudioFile_SaveAudioFileStart(FileName);
}

/*
*
*   2、存储音频文件中
*
*/
T_JZsdkReturnCode Megaphone_SaveAudioFileTrans(char *SaveData, int size)
{
    return AudioFile_SaveAudioFileTrans(SaveData, size);
}

/*
*
*   3、存储音频文件结束
*
*/
T_JZsdkReturnCode Megaphone_SaveAudioFileStop(int checkFlag, unsigned char *CheckCode)
{
    return AudioFile_SaveAudioFileStop(checkFlag, CheckCode);
}


T_JZsdkReturnCode Megaphone_Broadcast_OpusDecodeStatus(int status)
{
    UIcontrol_Broadcast_OpusDecodeStatus(status);
}



/****************************************************************************************************************************************************
*
*           录音喊话 接口部分
*
****************************************************************************************************************************************************/
/*
1、播放固定位置的opus音频
2、存储opus文件开始
3、存储opus文件中
4、存储opus文件结束
5、opus是否需要滤波
*/

/*********
 * 
 *  1、播放固定位置的opus音频
 * 
 * 
**********/
T_JZsdkReturnCode Megaphone_Opus_PlayFixedFile()
{
    memset(g_MegaphoneInfo, 0, sizeof(struct MegaphoneInfo));
    g_MegaphoneInfo->str_len = 0;

    return Megaphone_Play(g_MegaphoneInfo, AUDIO_PLAY_STATUS_OPUS_RECORD, JZ_FLAGCODE_ON);
}

/*********
 * 
 *  1、播放list列表的pcm音频
 * 
 * 
**********/
T_JZsdkReturnCode Megaphone_PlayPcmListFile(unsigned char *Filename,int len)
{
    memset(g_MegaphoneInfo, 0, sizeof(struct MegaphoneInfo));
    memcpy(g_MegaphoneInfo->str, Filename, len);
    g_MegaphoneInfo->str_len = len;

    return Megaphone_Play(g_MegaphoneInfo, AUDIO_PLAY_STATUS_PCM_LIST, JZ_FLAGCODE_ON);
}

/*
*
*   2、存储opus文件开始
*
*/
T_JZsdkReturnCode Megaphone_SaveOpusStart(unsigned char *FileName, int decode_rate, int SampleRate, int Channels)
{
    return OpusFile_SaveOpusFileStart(FileName , decode_rate, SampleRate, Channels);
}

/*
*
*   3、存储opus文件中
*
*/
T_JZsdkReturnCode Megaphone_SaveOpusTrans(char *SaveData, int size)
{
    return OpusFile_SaveOpusFileStream(SaveData, size);
}

/*
*
*   4、存储opus文件结束
*
*/
T_JZsdkReturnCode Megaphone_SaveOpusStop(int checkFlag, unsigned char *CheckCode)
{
    return OpusFile_SaveOpusFileEnd(checkFlag, CheckCode);
}



/****************************************************************************************************************************************************
*
*           opus实时喊话 接口部分
*
****************************************************************************************************************************************************/
/*********
 * 
 *  21、开始实时喊话
 * 
 * 
**********/
T_JZsdkReturnCode Megaphone_RealTimeVoice_Start(int decode_rate)
{
    //1、判断是否在开启实时喊话
    if ( Megaphone_RealTimeVoice_GetStatusFlag() == JZ_FLAGCODE_ON)
    {
        //是的话，无法进行操作
        return JZ_ERROR_SYSTEM_MODULE_CODE_IS_BUSY;
    }

    //把暂停音乐的标志关了
    AudioDeal_PauseAndContinuePlay(JZ_FLAGCODE_OFF);

    //关闭音乐
    Megaphone_StopPlay(JZ_FLAGCODE_OFF);

    T_JZsdkReturnCode ret = Opus_RealTimeVoice_Start(decode_rate);
    if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        //广播实时状态
        Megaphone_status_Broadcast(AUDIO_PLAY_STATUS_OPUS_REAL_TIME);
    }

    //开始实施喊话
    return ret;
}


/****
 * 
 * 
 *   22、写入数据进实时喊话的存储池
 * 
 * ***/
T_JZsdkReturnCode Megaphone_RealTimeVoice_Trans(char *data, int length)
{
    return Opus_RealTimeVoice_WriteDataToLoop(data, length);
}

/*********
 * 
 *  23、结束实时喊话
 * 
 * 
**********/
T_JZsdkReturnCode Megaphone_RealTimeVoice_Close()
{
    //1、关闭实时喊话
    T_JZsdkReturnCode ret = Opus_RealTimeVoice_Close();
    if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        //广播关闭
        Megaphone_status_Broadcast(AUDIO_PLAY_STATUS_IDLE);
    }
    
    return ret;
}


/****************************************************************************************************************************************************
*
*           MP2实时喊话 接口部分
*
****************************************************************************************************************************************************/
/*********
 * 
 *  开始MP2实时喊话
 * 
 * 
**********/
T_JZsdkReturnCode Megaphone_RealTimeMP2_start()
{   
    //1、判断是否在开启实时喊话
    if ( Megaphone_RealTimeVoice_GetStatusFlag() == JZ_FLAGCODE_ON)
    {
        //是的话，无法进行操作
        return JZ_ERRORCODE_REALTIMEVOICE_HAS_BEEN_ON;
    }

    //把暂停音乐的标志关了
    AudioDeal_PauseAndContinuePlay(JZ_FLAGCODE_OFF);

    //关闭音乐
    Megaphone_StopPlay(JZ_FLAGCODE_OFF);

    //开始MP2实时喊话
    T_JZsdkReturnCode ret = RealTimeMP2_start();
    if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        //广播关闭
        Megaphone_status_Broadcast(AUDIO_PLAY_STATUS_MP3_REAL_TIME);
    }

    return ret;
}

/****
 * 
 * 
 *   播放MP2数据
 * 
 * ***/
T_JZsdkReturnCode Megaphone_RealTimeMP2_trans(unsigned char *getdata, int len)
{
    return RealTimeMP2_trans(getdata, len);
}

/*********
 * 
 *  关闭MP2实时喊话
 * 
 * 
**********/
T_JZsdkReturnCode Megaphone_RealTimeMP2_stop()
{
    //关闭MP2实时喊话
    T_JZsdkReturnCode ret = RealTimeMP2_Close();
    if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        //广播关闭
        Megaphone_status_Broadcast(AUDIO_PLAY_STATUS_IDLE);
    }

    return ret;
}



/****************************************************************************************************************************************************
*
*           通用
*
****************************************************************************************************************************************************/

/************************
 * 
 *  设置/获取 功放引脚的参数
 *  
 * 
 * **********************/
T_JZsdkReturnCode Megaphone_Amplifier_param(int flagcode, int *value)
{
    if (flagcode == JZ_FLAGCODE_GET)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else if (flagcode == JZ_FLAGCODE_SET)
    {
        set_amplifier(*value);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    
    JZSDK_LOG_ERROR("参数获取出错");
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}

/*********************
 * 
 *  最大音量加载
 * 
 * ***********************/
static T_JZsdkReturnCode Megaphone_MaxVolume_Init()
{
    g_Max_volume = MAX_VOLUME;
    g_TTS_Max_volume = MAX_TTS_VOLUME;

    if (DEVICE_VERSION == JZ_H1T)
    {
        //检索版本号
        if (HardwareInfo_GetVersion(0) == 0x01
            && HardwareInfo_GetVersion(1) == 0x02
            && HardwareInfo_GetVersion(2) == 0x00
            && HardwareInfo_GetVersion(3) == 0x00
        )
        {
            g_Max_volume = 72;
            g_TTS_Max_volume = 81;
        }
    }

    JZSDK_LOG_INFO("MaxV:%d MaxTTS_V:%d",g_Max_volume, g_TTS_Max_volume);
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*********
 * 
 *  喊话器初始化
 * 
**********/
T_JZsdkReturnCode Megaphone_Init()
{
    if (MegaphoneStatusFlag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_ERROR("喊话器已初始化");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    JZsdk_Malloc((void **)&g_MegaphoneInfo, sizeof(struct MegaphoneInfo));

    //最大音量初始化
    Megaphone_MaxVolume_Init();

    //TTS功能初始化
	Megaphone_TTS_Init();

    //音频文件管理功能初始化
    Megaphone_AudioFile_Init();

    //pcm列表初始化
    Megaphone_PcmFile_Init();

    //设置音量
    Megaphone_SetVolume(30, 0);

    //温控初始化
    MegTempControl_Init();

    //根据属地设置默认语言
    int OriginValue = FOMAT_Get_FirewareOriginRegion();
    if (OriginValue == ORIGIN_DEFAULT || OriginValue == ORIGIN_CN)
    {
        int language = 0x01;
        Megaphone_TTS_param(JZ_FLAGCODE_SET, MEGAPHONE_TTS_TONE, &language);    
    }
    else
    {
        int language = 0x11;
        Megaphone_TTS_param(JZ_FLAGCODE_SET, MEGAPHONE_TTS_TONE, &language);   
    }
    
    MegaphoneStatusFlag = JZ_FLAGCODE_ON;
}


/*********
 * 
 *  喊话器参数
 * 
**********/
T_JZsdkReturnCode Megaphone_param(int flagcode, enum MegaphoneParam paramflag, int *value)
{
    T_JZsdkReturnCode ret;

    if (flagcode == JZ_FLAGCODE_GET)
    {
        switch (paramflag)
        {
            case MEGAPHONE_VOLUME:
            {
               *value = g_Megaphone_Volume;
            }
            break;           

            case MEGAPHONE_PLAY_STATUS:
            {
                //*value = g_Megaphone_Play_Status;
                *value = Megaphone_GetMegaphoneStatus();
            }
            break;        

            case MEGAPHONE_LOOP:
            {
                *value = g_Megaphone_Loop;
            }
            break;

            case MEGAPHONE_LOOP_INTERVAL:
            {
                *value = g_Megaphone_LoopInterval;
            }
            break;

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }
    
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else if (flagcode == JZ_FLAGCODE_SET)
    {
        switch (paramflag)
        {
            case MEGAPHONE_VOLUME:
            {
                if (*value < 0 || *value > 100)
                {
                    JZSDK_LOG_ERROR("喊话器音量设置失败");
                    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
                }
        
                Megaphone_PrintVolume(*value, 0);
            }
            break;

            case MEGAPHONE_PLAY_STATUS:
            {      
                g_Megaphone_Play_Status = *value;
            }
            break;

            case MEGAPHONE_LOOP:
            {
                JZSDK_LOG_INFO("设置循环:%d",*value);
                g_Megaphone_Loop = *value;
            }
            break;

            case MEGAPHONE_LOOP_INTERVAL:
            {
                JZSDK_LOG_INFO("设置循环间隔:%d",*value);
                g_Megaphone_LoopInterval = *value;
            }
            break;

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }
    
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    JZSDK_LOG_ERROR("参数获取出错");
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}

/***************
 * 
 *  获取实时喊话状态
 * 
 * *************/
T_JZsdkReturnCode Megaphone_RealTimeVoice_GetStatusFlag()
{
    //实时喊话的状态
    T_JZsdkReturnCode RealTimeStatus;

    //查询opus实施喊话的状态
    RealTimeStatus = Opus_RealTimeVoice_GetStatusFlag();
    if (RealTimeStatus == JZ_FLAGCODE_ON)
    {
        printf("实时喊话状态查询:正在进行opus实时喊话\n");
        return JZ_FLAGCODE_ON;
    }
    
    //查询实时MP2状态
    RealTimeStatus = RealTimeMP2_GetStatusFlag();
    if (RealTimeStatus == JZ_FLAGCODE_ON)
    {
        printf("实时喊话状态查询:正在进行实时MP2\n");
        return JZ_FLAGCODE_ON;
    }  

    //都没有在播放
    return JZ_FLAGCODE_OFF;
}

/***************
 * 
 *  继续音频播放
 * 
 * *************/
T_JZsdkReturnCode Megaphone_PlayContinue()
{
    //1、判断是否在开启实时喊话
    if ( Megaphone_RealTimeVoice_GetStatusFlag() == JZ_FLAGCODE_ON)
    {
        //是的话，无法进行操作
        return JZ_ERRORCODE_REALTIMEVOICE_HAS_BEEN_ON;
    }

    //打开功放
    int ami =JZ_FLAGCODE_ON;
    Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &ami);

    //查看播放状态是否不处于停止
    if (g_Megaphone_Play_Status == AUDIO_PLAY_STATUS_IDLE)
    {
             //播放当前音频
        unsigned char CurrentName[128];
        memset(CurrentName,0,sizeof(CurrentName));
        unsigned int CurrentNameLen = 0;
        unsigned int CurrentNum = 0;
        AudioMange_Get_FilePlayName(CurrentName, &CurrentNameLen, &CurrentNum);
        UIcontrol_PlayAudioFile(NO_SPECIFIED ,CurrentName, CurrentNameLen);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
      
    }
    else if (g_Megaphone_Play_Status == AUDIO_PLAY_STATUS_MUSIC)
    {
        AudioDeal_PauseAndContinuePlay(JZ_FLAGCODE_OFF);
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
}

/***************
 * 
 *  暂停音频播放
 * 
 * *************/
T_JZsdkReturnCode Megaphone_PlayPause()
{
    //1、判断是否在开启实时喊话
    if ( Megaphone_RealTimeVoice_GetStatusFlag() == JZ_FLAGCODE_ON)
    {
        //是的话，无法进行操作
        return JZ_ERRORCODE_REALTIMEVOICE_HAS_BEEN_ON;
    }

    //关闭功放
    int ami =JZ_FLAGCODE_OFF;
    Megaphone_Amplifier_param(JZ_FLAGCODE_SET, &ami);
    
    if (g_Megaphone_Play_Status == AUDIO_PLAY_STATUS_MUSIC)
    {
        AudioDeal_PauseAndContinuePlay(JZ_FLAGCODE_ON);
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/*********************
 * 
 *  喊话器状态转换
 * 
 * ****************************/
static T_JZsdkReturnCode Megaphone_ConvertPlayStatus(int status)
{
    //A、查询是否在播放音频
    if (status == AUDIO_PLAY_STATUS_MUSIC)
    {
        return 0x10;
    }
    
    //B、查询是否在播放文本
    if (status == AUDIO_PLAY_STATUS_IFLAY_TTS
        || status == ADDIO_PLAY_STATUS_ESPEAK_TTS
    )
    {
        return 0x20;
    }

    //C、查询是否在播放opus
    if (status == AUDIO_PLAY_STATUS_OPUS_RECORD
    )
    {
        return 0x30;
    }

    //D、查询是否在播放实时喊话
    if (status == AUDIO_PLAY_STATUS_OPUS_REAL_TIME
        || status == AUDIO_PLAY_STATUS_MP3_REAL_TIME
    )
    {
        return 0x40;
    }

    if (status == AUDIO_PLAY_STATUS_PCM_LIST)
    {
        return 0x50;
    }
    

    if (status == AUDIO_PLAY_STATUS_IDLE)
    {
        return 0x00;
    }
}


/***************
 * 
 *  获取喊话器状态
 *  
 * *************/
int Megaphone_GetMegaphoneStatus()
{
    int Megahone_status = Megaphone_ConvertPlayStatus(g_Megaphone_Play_Status);
    return Megahone_status;
}

/*****************
 * 
 *  获取歌曲聊表
 * 
 * *************/
T_JZsdkReturnCode Megaphone_GetMusicListMessage(unsigned char *message)
{
    T_JZsdkReturnCode ret;

    //获取歌曲总数
    unsigned int MusicNum = 0;
    AudioMange_Get_FileNum(&MusicNum);
    if (MusicNum == 0)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    //获取当前播放的名字
    unsigned char CurrentName[128];
    memset(CurrentName,0,sizeof(CurrentName));
    unsigned int CurrentNameLen = 0;
    unsigned int CurrentNum = 0;
    AudioMange_Get_FilePlayName(CurrentName, &CurrentNameLen, &CurrentNum);

    //拼接
    snprintf(message,1024,"[%d/%d]▶:%s\n",CurrentNum ,MusicNum, CurrentName);
    //JZSDK_LOG_DEBUG("%s",message);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



/****************************************************************************************************************************************************
*
*           音量调节
*
****************************************************************************************************************************************************/
int now_volume=20;//默认音量10--》50+10/2==55
static void *Meg_SetVolumeTask(void *arg);
static T_JZsdkReturnCode Megaphone_SetTTSvolume();

/*********************
 * 
 *  mode == 0 正常调音量
 *  mode == 1 tts调音量
 * 
 * ************************/
T_JZsdkReturnCode Megaphone_SetVolume(int value, int mode)//设置音量，音量0-100，默认音量value==10。
{
	pthread_t SET_volume_task;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程属性
	printf("传入的值:%d\n",value);

	
	if (mode == 1)
	{
		return 	Megaphone_SetTTSvolume();
	}

    now_volume=value;//获取当前音量
	
	//v3s自设系统 10T要提高30初始音量
	if (DEVICE_VERSION == JZ_H10T || DEVICE_VERSION == JZ_U3 || DEVICE_VERSION == JZ_U3S || DEVICE_VERSION == JZ_U3D || DEVICE_VERSION == JZ_U30)
	{
		if (value > 0)
		{
			value = 30 + value * 10/7;
		}
	}

	if(value<=0)
	{
		value=0;
	}

	else if(value>0&&value<100)
	{
		value=value*g_Max_volume/100 *255/100;
	}

	else if(value>=100)
	{
		value=100*g_Max_volume/100 *255/100;
	}

    int* set_volume_value_ptr = malloc(sizeof(int)); // 动态分配内存  
    if (set_volume_value_ptr == NULL) 
    {  
        JZSDK_LOG_ERROR("设置音量失败");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  
        
    *set_volume_value_ptr = value;

    int volume_ret = pthread_create(&SET_volume_task,&task_attribute,Meg_SetVolumeTask,set_volume_value_ptr);		//TTS线程
    if(volume_ret != 0)
    {
        JZSDK_LOG_ERROR("设置音量失败");
        free(set_volume_value_ptr);
        set_volume_value_ptr = NULL;
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
}

static T_JZsdkReturnCode Megaphone_SetTTSvolume()
{
	pthread_t SET_volume_task;
	pthread_attr_t task_attribute; //线程属性
	pthread_attr_init(&task_attribute);  //初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED);      //设置线程属性
	
	int value = now_volume;
	printf("TTS音量修改\n");

	//v3s自设系统 10T要提高30初始音量
	if (DEVICE_VERSION == JZ_H10T || DEVICE_VERSION == JZ_U3 || DEVICE_VERSION == JZ_U3S || DEVICE_VERSION == JZ_U3D || DEVICE_VERSION == JZ_U30)
	{
		if (value > 0)
		{
			value = 30 + value * 10/7;
		}
	}


	if(value<=0)
	{
		value=0;
	}

	else if(value>0&&value<100)
	{
		value=value*g_TTS_Max_volume/100 *255/100;
	}

	else if(value>=100)
	{
		value=100*g_TTS_Max_volume/100 *255/100;
	}

    int* set_volume_value_ptr = malloc(sizeof(int)); // 动态分配内存  
    if (set_volume_value_ptr == NULL) 
    {  
        JZSDK_LOG_ERROR("设置音量失败");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  
        
    *set_volume_value_ptr = value;

    int volume_ret = pthread_create(&SET_volume_task,&task_attribute,Meg_SetVolumeTask,set_volume_value_ptr);		//TTS线程
    if(volume_ret != 0)
    {
        JZSDK_LOG_ERROR("设置音量失败");
        free(set_volume_value_ptr);
        set_volume_value_ptr = NULL;
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
}

T_JZsdkReturnCode Meg_SetVolumeFun(int volume)
{
    char cmdBuffer[128];

    if (DEVICE_VERSION == JZ_H150S || DEVICE_VERSION == JZ_H150T || DEVICE_VERSION == JZ_H10)
	{
		snprintf(cmdBuffer,128, "amixer set -c 4 Master %d",volume);
	}
	else if (DEVICE_VERSION == JZ_H1E || DEVICE_VERSION == JZ_H1T || DEVICE_VERSION == TF_A1)
	{
		snprintf(cmdBuffer,128, "amixer set -c 0 Master %d",volume);
	}
	else if (DEVICE_VERSION == JZ_H10T || DEVICE_VERSION == JZ_U3 || DEVICE_VERSION == JZ_U3S || DEVICE_VERSION == JZ_U3D || DEVICE_VERSION == JZ_U30)
	{
		snprintf(cmdBuffer,128, "amixer sset -c 0 'Headphone' %d unmute",volume);
	}
	
    g_Megaphone_RealSetVolue = volume;
	JZsdk_RunSystemCmd(cmdBuffer);
	printf("线程设置音量为:%d\n",volume);
}

static void *Meg_SetVolumeTask(void *arg)
{
	
    int *volume_value = (int*)arg;  
    g_Megaphone_RealTargetVolume = *volume_value; //记录一下实际设置的声音大小

    Meg_SetVolumeFun(*volume_value);

    free(volume_value);
}

/***
 * 
 * 
 *  获取当前音量值
 * 
 * ***/
int Megaphone_get_now_volume()
{
	return now_volume;
}

/***
 * 
 * 
 *  获取实际设置音量值
 * 
 * ***/
int Megaphone_get_RealSetVolume()
{
	return g_Megaphone_RealSetVolue;
}

/***
 * 
 * 
 *  获取实际目标音量值
 * 
 * ***/
int Megaphone_get_RealTargetVolume()
{
	return g_Megaphone_RealTargetVolume;
}


/***
 * 
 *  显示音量函数 范围0~100
 *  如果通过设置ui的音量 则flag = 0
 *  如果是温控调整音量，则flag = 1
 * ***/
T_JZsdkReturnCode Megaphone_PrintVolume(int Value, int flag)
{
   
    //正常设置音量
    if (flag == 0)
    {
        g_Megaphone_Volume = Value;

        Megaphone_SetVolume(g_Megaphone_Volume, 0);
    }
    
    //温控调整音量
    if (flag == 1)
    {
        //根据调整量反应到ui界面上
        //分为文本和歌曲
        int PlayStatus = Megaphone_GetMegaphoneStatus();
        int Ui_num = 0;
        int HundredMarkNum = 0;

#if DEVICE_VERSION == JZ_H1T
        HundredMarkNum = (Value * 100 /255);
#else
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
#endif

        //如果是文本
        if (PlayStatus == 0x20)
        {
            //计算出ui值
            Ui_num = HundredMarkNum * 100 / g_TTS_Max_volume;
        }
        else
        {
            //计算出ui值
            Ui_num = HundredMarkNum * 100 / g_Max_volume;
        }

        if (g_Megaphone_Volume > Ui_num)
        {
            g_Megaphone_Volume--;     
        }
        else if (g_Megaphone_Volume < Ui_num)
        {
            g_Megaphone_Volume++;        
        }
        else
        {
            return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
        }

        //修改ui值
            
        //通知其他设备的ui界面变化
        //如果4G模块有启动
        if ( (JZsdk_HalPort_UseFlag(UART_4G) == JZ_FLAGCODE_ON))
        {
            HalSend_type1Send_Reply_Volume(UART_4G, g_Megaphone_Volume);
        }
        //如果设备1有启动
        if ( (JZsdk_HalPort_UseFlag(UART_DEV_1) == JZ_FLAGCODE_ON)  )
        {
            HalSend_type1Send_Reply_Volume(UART_DEV_1, g_Megaphone_Volume);
        }
        //如果设备2有启动
        if ( (JZsdk_HalPort_UseFlag(UART_DEV_2) == JZ_FLAGCODE_ON) )
        {
            HalSend_type1Send_Reply_Volume(UART_DEV_2, g_Megaphone_Volume);
        }
        //如果psdk接口已经使用
        if ( (JZsdk_HalPort_UseFlag(DEVICE_PSDK) == JZ_FLAGCODE_ON))
        {
            JZsdk_Psdk_UI_io_Reply_Volume(g_Megaphone_Volume);
        }
    }
    
}