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


#include "JZsdkLib.h"
#include "Megaphone_InputAndOutput.h"
#include "../opus.h" 
#include "version_choose.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 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 Opus_RealTimeVoice_ClearLoop();//清空缓存池
static void Opus_RealTimeVoice_PlayLoop_HeadReset();

static int Opus_RealTimeVoice_DecodeAndPlay_init();
static void *Opus_RealTimeVoice_LoopPlay(void *arg);
static int Opus_RealTimeVoice_AbnormalInterrupt();
static int Opus_RealTimeVoice_DeinitDecoder();


//写入数据部分
static unsigned char Opus_RealTimeVoice_WriteDataLoop[ (15 + 1) ][80];//写入缓存池 最高同时存15组数据 用于写入缓冲
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 void Opus_RealTimeVoice_WriteDataHeadReset();
static int Opus_RealTimeVoice_WriteDataClear();//清空写入缓存池
static int Opus_RealTimeVoice_WriteData_init();
static void *Opus_RealTimeVoice_WriteData_Task(void *arg);

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

	//1、开始实时喊话模式
	ReadTimeVoice_StatusFlag = JZ_FLAGCODE_ON; 
	RealTimeDecodeRate = decode_rate;

	//2、创建线程输入缓冲池线程
	Opus_RealTimeVoice_WriteData_init();

	//3、创建解码线程
	Opus_RealTimeVoice_DecodeAndPlay_init();

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

	return 0 ;
}


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

	//清空播放数据缓冲区
	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("创建自动解码线程失败！");
		ReadTimeVoice_StatusFlag = JZ_FLAGCODE_OFF;
		return -2;
	}
#else
	return -1;
#endif
}

//解码opus并播放
static int Opus_RealTimeVoice_PlayData(unsigned char *data,int len)
{
#if MEGAPHONE_MODE == VERSION_SWITCH_ON
	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 ];
	
	//解码
	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) {
        JZSDK_LOG_ERROR("decoder failed");
        return -1;
    }

	//转换		
	for (i = 0; i < WIDGET_SPEAKER_AUDIO_OPUS_CHANNELS * frame_size; i++) {								
            pcm_bytes[2 * i] = out[i] & 0xFF;
            pcm_bytes[2 * i + 1] = (out[i] >> 8) & 0xFF;
    }

	Megaphone_RawPlay(RealTimeDecodeRate,pcm_bytes,frame_size*2);//播放音频
#endif
	return 0;
}


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

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

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

		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 < 0)
			{
				break;
			}
		}
	}

	Opus_RealTimeVoice_LoopReadStopFlag = JZ_FLAGCODE_OFF;

	if (ReadTimeVoice_StatusFlag == JZ_FLAGCODE_OFF)
	{
		//录音喊话异常中断
		Opus_RealTimeVoice_AbnormalInterrupt();

		JZSDK_LOG_INFO("实时喊话关闭\n");
	}
	else
	{
		JZSDK_LOG_ERROR("实时喊话解码器出错");
		//录音喊话异常中断
		Opus_RealTimeVoice_AbnormalInterrupt();
		
		//重新开始解码播放流程
		Opus_RealTimeVoice_Start(RealTimeDecodeRate);
	}

}

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

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

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

	printf("清空播放缓冲池");
}

/************************************************************************************************************************************************
 * 
 *      写入缓冲池部分
 * 
 * 
*************************************************************************************************************************************************/
//写入数据部分初始化
static int 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("创建输入缓冲池线程线程失败！");
		ReadTimeVoice_StatusFlag = JZ_FLAGCODE_OFF;
		return -2;
	}
}

//将输入缓冲池的数据放入播放缓冲池
static int 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 int Opus_RealTimeVoice_WriteDataClear()
{
	Opus_RealTimeVoice_WriteData_LoopHead=0;
	Opus_RealTimeVoice_WriteData_LoopEnd=0;
	Opus_RealTimeVoice_WriteData_ResidueLenth = 0;

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


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

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

//写入数据进缓存池,以用于后续播放
int Opus_RealTimeVoice_WriteDataToLoop(unsigned char *buf,int length)
{

	int temp_lenth = 0;  //临时长度

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

	if (ReadTimeVoice_StatusFlag != JZ_FLAGCODE_ON)
	{
		JZSDK_LOG_ERROR("实时喊话未开启");
		return -1;
	}
	
	//写入处理
	//① 、检查池子当前组内有无剩余数据，如果池子当前组有剩  上次写入的语音数据， 接着往里面写入
	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 0;
		}
		//足够就是正常步骤
		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 ++;
		}	
	
	}


	return 0;
}


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


//释放解码器
static int Opus_RealTimeVoice_DeinitDecoder()
{
#if MEGAPHONE_MODE == VERSION_SWITCH_ON
	//1、关闭线程
	Opus_RealTimeVoice_LoopReadFlag=JZ_FLAGCODE_OFF;//关闭解码数据池自读
	while (Opus_RealTimeVoice_LoopReadStopFlag == JZ_FLAGCODE_ON)
	{
		delayMs(1);
	}
	
	Opus_RealTimeVoice_WriteDataFlag = JZ_FLAGCODE_OFF;//关闭写入数据池
	while (Opus_RealTimeVoice_WriteDataStopFlag == JZ_FLAGCODE_ON)
	{
		delayMs(1);
	}	
	
	printf("自动线程关闭完毕\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("解码器为空");
	}
#endif
}


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

/*
	Opus 实时语音异常中断
	客户在打开实时语音下，忘记关闭，进行其他操作，需要及时关闭语音，并清除内存
*/
static int Opus_RealTimeVoice_AbnormalInterrupt()
{
	//如果喊话模式没被打开，就没必要跑了, 不然释放空的解码器会导致奔溃
	if (ReadTimeVoice_StatusFlag == JZ_FLAGCODE_ON)
	{
		//释放解码器
		Opus_RealTimeVoice_DeinitDecoder();
	}
}



/**************************
 * 
 *  实时喊话关闭
 * 
 * ***************************/
int Opus_RealTimeVoice_Close()
{
	ReadTimeVoice_StatusFlag = JZ_FLAGCODE_OFF;

	//释放解码器
	Opus_RealTimeVoice_DeinitDecoder();
}