/*
 * Copyright 2021 Rockchip Electronics Co. LTD
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif /* End of #ifdef __cplusplus */

#include <assert.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "sample_comm.h"

typedef struct _rkMpiCtx {
	SAMPLE_AI_CTX_S ai;
	SAMPLE_AENC_CTX_S aenc;
} SAMPLE_MPI_CTX_S;

static bool quit = false;
static void sigterm_handler(int sig) {
	fprintf(stderr, "signal %d\n", sig);
	quit = true;
}

static RK_CODEC_ID_E code_type = RK_AUDIO_ID_MP2;

#define MP3_PROFILE_LOW 1

typedef struct FreqIdx_ {
	RK_S32 u32SmpRate;
	RK_U8 u8FreqIdx;
} FreqIdx;

FreqIdx FreqIdxTbl[13] = {{96000, 0},  {88200, 1}, {64000, 2}, {48000, 3}, {44100, 4},
                          {32000, 5},  {24000, 6}, {22050, 7}, {16000, 8}, {12000, 9},
                          {11025, 10}, {8000, 11}, {7350, 12}};

static void GetHeader(RK_U8 *pu8Hdr, RK_S32 u32SmpRate, RK_U8 u8Channel,
                      RK_U32 u32DataLen) {
	RK_U8 u8FreqIdx = 0;
	for (int i = 0; i < 13; i++) {
		if (u32SmpRate == FreqIdxTbl[i].u32SmpRate) {
			u8FreqIdx = FreqIdxTbl[i].u8FreqIdx;
			break;
		}
	}

	RK_U32 u32PacketLen = u32DataLen + 7;
	pu8Hdr[0] = 0xFF;
	pu8Hdr[1] = 0xF1;
	pu8Hdr[2] = ((MP3_PROFILE_LOW) << 6) + (u8FreqIdx << 2) + (u8Channel >> 2);
	pu8Hdr[3] = (((u8Channel & 3) << 6) + (u32PacketLen >> 11));
	pu8Hdr[4] = ((u32PacketLen & 0x7FF) >> 3);
	pu8Hdr[5] = (((u32PacketLen & 7) << 5) + 0x1F);
	pu8Hdr[6] = 0xFC;
}

/******************************************************************************
 * function : aenc thread
 ******************************************************************************/
static void *aenc_get_stream(void *pArgs) {
	SAMPLE_AENC_CTX_S *ctx = (SAMPLE_AENC_CTX_S *)(pArgs);
	RK_S32 s32Ret = RK_FAILURE;
	char name[256] = {0};
	FILE *fp = RK_NULL;
	void *pData = RK_NULL;
	RK_S32 loopCount = 0;
	RK_U8 header[7];

	if (ctx->dstFilePath) {
		snprintf(name, sizeof(name), "/%s/aenc_%d.bin", ctx->dstFilePath, ctx->s32ChnId);
		fp = fopen(name, "wb");
		if (fp == RK_NULL) {
			printf("chn %d can't open %s file !\n", ctx->s32ChnId, ctx->dstFilePath);
			quit = true;
			return RK_NULL;
		}
	}

	while (!quit) {
		s32Ret = SAMPLE_COMM_AENC_GetStream(ctx, &pData);
		if (s32Ret == RK_SUCCESS) {
			// exit when complete
			if (ctx->s32loopCount > 0) {
				if (loopCount >= ctx->s32loopCount) {
					SAMPLE_COMM_AENC_ReleaseStream(ctx);
					quit = true;
					break;
				}
			}

			if (fp) {
				if (code_type == RK_AUDIO_ID_MP3) {
					GetHeader(header, ctx->stChnAttr.stCodecAttr.u32SampleRate,
					          ctx->stChnAttr.stCodecAttr.u32Channels,
					          ctx->stFrame.u32Len);
					fwrite(header, 1, 7, fp);
				}
				fwrite(pData, 1, ctx->stFrame.u32Len, fp);
				fflush(fp);
			}

			RK_LOGE("chn:%d, loopCount:%d wd:%d\n", ctx->s32ChnId, loopCount,
			        ctx->stFrame.u32Len);

			SAMPLE_COMM_AENC_ReleaseStream(ctx);
			loopCount++;
		}
		usleep(1000);
	}

	if (fp)
		fclose(fp);

	return NULL;
}

static RK_CHAR optstr[] = "?::d:w:R:r:C:c:e:l:o:";
static void print_usage(const RK_CHAR *name) {
	printf("usage example:\n");
	printf("\t%s -d default:CARD=rockchipes8388 -w 16bit -R 16000 -r 16000 -C 2 -c 2 -e "
	       "mp2 -o /data/\n",
	       name);
	printf("\t-d | --device_name: the sound name for open sound card, eg: "
	       "default:CARD=rockchipes8388c Default(NULL)\n");
	printf("\t-w | --bit_width: the bit width of open sound card, Default:16bit, "
	       "Value:8bit, 16bit, 24bit\n");
	printf("\t-R | --device_rate: the sample rate of open sound card, Default:16000\n");
	printf("\t-r | --out_rate: the sample rate of out data, Default:16000\n");
	printf("\t-C | --device_ch: the number of sound card channels, Default:2\n");
	printf("\t-c | --out_ch: the channels of out data, Default:2\n");
	printf("\t-e | --encode: encode type, Defaule:mp3, Value:mp3, mp2, g711a, g711u, "
	       "g726\n");
	printf("\t-l | --loop_count: loop running count, Default -1\n");
	printf("\t-o | --output_path: encode save file path, Default /data/\n");
}

int main(int argc, char *argv[]) {
	SAMPLE_MPI_CTX_S *ctx;
	MPP_CHN_S stSrcChn, stDestChn;
	RK_S32 s32DeviceChannel = 2;
	RK_S32 s32DeviceSampleRate = 16000;
	AUDIO_BIT_WIDTH_E bitWidth = AUDIO_BIT_WIDTH_16;
	RK_S32 s32SampleRate = 8000;
	AUDIO_SOUND_MODE_E soundMode = AUDIO_SOUND_MODE_STEREO;
	RK_S32 s32ChnCnt = 2;
	RK_S32 s32PeriodCount = 4;
	RK_S32 s32PeriodSize = 1024;
	RK_S32 s32loopCnt = -1;
	RK_CHAR *pCardName = NULL;
	RK_CHAR *pOutPath = NULL;
	int c;

	if (argc < 2) {
		print_usage(argv[0]);
		return 0;
	}

	ctx = (SAMPLE_MPI_CTX_S *)(malloc(sizeof(SAMPLE_MPI_CTX_S)));
	memset(ctx, 0, sizeof(SAMPLE_MPI_CTX_S));

	signal(SIGINT, sigterm_handler);

	while ((c = getopt(argc, argv, optstr)) != -1) {
		switch (c) {
		case 'd':
			pCardName = optarg;
			break;
		case 'r':
			s32SampleRate = atoi(optarg);
			break;
		case 'R':
			s32DeviceSampleRate = atoi(optarg);
			break;
		case 'c':
			s32ChnCnt = atoi(optarg);
			break;
		case 'C':
			s32DeviceChannel = atoi(optarg);
			break;
		case 'w':
			if (!strcmp(optarg, "8bit")) {
				bitWidth = AUDIO_BIT_WIDTH_8;
			} else if (!strcmp(optarg, "16bit")) {
				bitWidth = AUDIO_BIT_WIDTH_16;
			} else if (!strcmp(optarg, "24bit")) {
				bitWidth = AUDIO_BIT_WIDTH_24;
			}
			break;
		case 'o':
			pOutPath = optarg;
			break;
		case 'e':
			if (!strcmp(optarg, "mp2")) {
				code_type = RK_AUDIO_ID_MP2;
			} else if (!strcmp(optarg, "mp3")) {
				code_type = RK_AUDIO_ID_MP3;
			} else if (!strcmp(optarg, "g726")) {
				code_type = RK_AUDIO_ID_ADPCM_G726;
			} else if (!strcmp(optarg, "g711a")) {
				code_type = RK_AUDIO_ID_PCM_ALAW;
			} else if (!strcmp(optarg, "g711u")) {
				code_type = RK_AUDIO_ID_PCM_MULAW;
			}
			break;
		case 'l':
			s32loopCnt = atoi(optarg);
			break;
		case '?':
		default:
			print_usage(argv[0]);
			return 0;
		}
	}

	if (s32ChnCnt == 1) {
		soundMode = AUDIO_SOUND_MODE_MONO;
	} else if (s32ChnCnt == 2) {
		soundMode = AUDIO_SOUND_MODE_STEREO;
	} else {
		printf("%s channel = %d not support\n", __func__, s32ChnCnt);
		return 0;
	}

	printf("#Device: %s\n", pCardName);
	printf("#SampleRate: %d\n", s32SampleRate);
	printf("#Channel Count: %d\n", s32ChnCnt);
	printf("#Loop Count: %d\n", s32loopCnt);
	printf("#Output Path: %s\n", pOutPath);
	printf("#code_type: %d\n", code_type);

	RK_MPI_SYS_Init();

	// Init AI[0]
	ctx->ai.s32DevId = 0;
	ctx->ai.s32ChnId = 0;
	ctx->ai.stAiAttr.soundCard.channels = s32DeviceChannel;
	ctx->ai.stAiAttr.soundCard.sampleRate = s32DeviceSampleRate;
	ctx->ai.stAiAttr.soundCard.bitWidth = bitWidth;
	ctx->ai.stAiAttr.enBitwidth = bitWidth;
	ctx->ai.stAiAttr.enSamplerate = (AUDIO_SAMPLE_RATE_E)s32SampleRate;
	ctx->ai.stAiAttr.enSoundmode = soundMode;
	ctx->ai.stAiAttr.u32FrmNum = s32PeriodCount;
	ctx->ai.stAiAttr.u32PtNumPerFrm = s32PeriodSize;
	ctx->ai.stAiAttr.u32EXFlag = 0;
	ctx->ai.stAiAttr.u32ChnCnt = s32ChnCnt;
	if (pCardName) {
		strcpy(ctx->ai.stAiAttr.u8CardName, pCardName);
	}
	SAMPLE_COMM_AI_CreateChn(&ctx->ai);

	// Init AENC[0]
	ctx->aenc.s32ChnId = 0;
	ctx->aenc.s32loopCount = s32loopCnt;
	ctx->aenc.stChnAttr.enType = code_type;
	ctx->aenc.stChnAttr.stCodecAttr.u32Channels = s32ChnCnt;
	ctx->aenc.stChnAttr.stCodecAttr.u32SampleRate = s32SampleRate;
	ctx->aenc.stChnAttr.stCodecAttr.enBitwidth = bitWidth;
	ctx->aenc.stChnAttr.u32BufCount = 4;
	ctx->aenc.dstFilePath = pOutPath;
	SAMPLE_COMM_AENC_CreateChn(&ctx->aenc);

	// Bind AI[0] and AENC[0]
	stSrcChn.enModId = RK_ID_AI;
	stSrcChn.s32DevId = ctx->ai.s32DevId;
	stSrcChn.s32ChnId = ctx->ai.s32ChnId;
	stDestChn.enModId = RK_ID_AENC;
	stDestChn.s32DevId = 0;
	stDestChn.s32ChnId = ctx->aenc.s32ChnId;
	SAMPLE_COMM_Bind(&stSrcChn, &stDestChn);

	pthread_t getStreamThread;
	pthread_create(&getStreamThread, NULL, aenc_get_stream, (void *)(&ctx->aenc));

	printf("%s initial finish\n", __func__);

	while (!quit) {
		usleep(500000);
	}

	printf("%s exit!\n", __func__);

	pthread_join(getStreamThread, NULL);

	// UnBind AI[0] and AENC[0]
	stSrcChn.enModId = RK_ID_AI;
	stSrcChn.s32DevId = ctx->ai.s32DevId;
	stSrcChn.s32ChnId = ctx->ai.s32ChnId;
	stDestChn.enModId = RK_ID_AENC;
	stDestChn.s32DevId = 0;
	stDestChn.s32ChnId = ctx->aenc.s32ChnId;
	SAMPLE_COMM_UnBind(&stSrcChn, &stDestChn);

	// Destroy AENC[0]
	SAMPLE_COMM_AENC_DestroyChn(&ctx->aenc);
	// Destroy AI[0]
	SAMPLE_COMM_AI_DestroyChn(&ctx->ai);

	RK_MPI_SYS_Exit();

	return 0;
}

#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */