amaudio/src/amAudio.cpp - yocto/linux/multimedia - Git Browser for ODROID

 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/poll.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>

 #include <pthread.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>

 #include "amAudio.h"

 #define LOG_TAG "amAudio_Test"

 #undef LOGI
 #define LOGI(fmt, ...) printf("I/%s: ", LOG_TAG);printf(fmt, ##__VA_ARGS__);
 #undef LOGE
 #define LOGE(fmt, ...) printf("E/%s: ", LOG_TAG);printf(fmt, ##__VA_ARGS__);
 #undef LOGD
 #define LOGD(fmt, ...) printf("D/%s: ", LOG_TAG);printf(fmt, ##__VA_ARGS__);

 //#define WRITE_AUDIO_OUT_TO_FILE
 #define SELF_TEST

 #define AUDIO_IN									"/dev/amaudio_in"
 #define AUDIO_OUT									"/dev/amaudio_out"

 #define AMAUDIO_IOC_MAGIC							'A'
 #define AMAUDIO_IOC_GET_I2S_OUT_SIZE				_IOW(AMAUDIO_IOC_MAGIC, 0x00, int)
 #define AMAUDIO_IOC_GET_I2S_OUT_PTR					_IOW(AMAUDIO_IOC_MAGIC, 0x01, int)
 #define AMAUDIO_IOC_SET_I2S_OUT_RD_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x02, int)
 #define AMAUDIO_IOC_GET_I2S_IN_SIZE					_IOW(AMAUDIO_IOC_MAGIC, 0x03, int)
 #define AMAUDIO_IOC_GET_I2S_IN_PTR					_IOW(AMAUDIO_IOC_MAGIC, 0x04, int)
 #define AMAUDIO_IOC_SET_I2S_IN_RD_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x05, int)
 #define AMAUDIO_IOC_SET_I2S_IN_MODE					_IOW(AMAUDIO_IOC_MAGIC, 0x06, int)
 #define AMAUDIO_IOC_SET_I2S_OUT_MODE				_IOW(AMAUDIO_IOC_MAGIC, 0x07, int)
 #define AMAUDIO_IOC_GET_I2S_IN_RD_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x08, int)
 #define AMAUDIO_IOC_GET_I2S_OUT_RD_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x09, int)
 #define AMAUDIO_IOC_SET_I2S_IN_WR_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x0a, int)
 #define AMAUDIO_IOC_SET_I2S_OUT_WR_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x0b, int)
 #define AMAUDIO_IOC_GET_I2S_IN_WR_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x0c, int)
 #define AMAUDIO_IOC_GET_I2S_OUT_WR_PTR				_IOW(AMAUDIO_IOC_MAGIC, 0x0d, int)
 #define AMAUDIO_IOC_SET_LEFT_MONO					_IOW(AMAUDIO_IOC_MAGIC, 0x0e, int)
 #define AMAUDIO_IOC_SET_RIGHT_MONO					_IOW(AMAUDIO_IOC_MAGIC, 0x0f, int)
 #define AMAUDIO_IOC_SET_STEREO						_IOW(AMAUDIO_IOC_MAGIC, 0x10, int)
 #define AMAUDIO_IOC_SET_CHANNEL_SWAP				_IOW(AMAUDIO_IOC_MAGIC, 0x11, int)
 #define AMAUDIO_IOC_DIRECT_AUDIO					_IOW(AMAUDIO_IOC_MAGIC, 0x12, int)
 #define AMAUDIO_IOC_DIRECT_LEFT_GAIN  				_IOW(AMAUDIO_IOC_MAGIC, 0x13, int)
 #define AMAUDIO_IOC_DIRECT_RIGHT_GAIN 				_IOW(AMAUDIO_IOC_MAGIC, 0x14, int)

 #define M_AUDIO_THREAD_DELAY_TIME					4000
 #define AUDIO_BUFFER_SIZE							19200

 static int amAudio_InHandle = -1;
 static int amAudio_OutHandle = -1;
 static int amAudio_InSize = -1;
 static int amAudio_OutSize = -1;
 static unsigned char *amAudio_In_BufAddr = NULL;
 static unsigned char *amAudio_Out_BufAddr = NULL;
 unsigned char *inbuffer_current_position = NULL;
 unsigned char *outbuffer_current_position = NULL;

 unsigned char *amAudio_In_BufAddr_half = NULL;
 unsigned char *amAudio_Out_BufAddr_half = NULL;

 static pthread_t amAudio_ThreadID = 0;
 static int amAudio_ThreadExitFlag = 0;

 #define NODATA  0
 #define BUFFER1_READY 1
 #define BUFFER2_READY 2

 typedef struct Buffer_status {
 	int status;
 	unsigned char *user_read;
 } Buffer_status;

 Buffer_status Output_buffer_status;

 #ifdef WRITE_AUDIO_OUT_TO_FILE
 static FILE *FileIn = NULL;
 static FILE *FileOut = NULL;

 #endif

 static int amAudio_InInit(void)
 {
 	unsigned int hwptr;

 	hwptr = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_PTR);
 	if (hwptr == 0xFFFFFFFF)
 	{
 		LOGI("amAudio_InInit Error!\n");
 		return -1;
 	}
     ioctl (amAudio_InHandle, AMAUDIO_IOC_SET_I2S_IN_RD_PTR, hwptr);
 	inbuffer_current_position = amAudio_In_BufAddr;
     return 0;
 }

 static int amAudio_OutInit(void)
 {
 	unsigned int hwptr;

 	hwptr= ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_PTR);
 	if (hwptr == 0xFFFFFFFF)
 	{
 		LOGI("amAudio_OutInit Error!\n");
 		return -1;
 	}
 	ioctl (amAudio_OutHandle, AMAUDIO_IOC_SET_I2S_OUT_RD_PTR, hwptr);
 	outbuffer_current_position = amAudio_Out_BufAddr;
 	return 0;
 }

 static int amAudio_InProc(void)
 {
 	int Ret;
 	int hwptr;
 	int rdptr;
 	int Bytes;
 	int PosBytes;
 	int left_size = AUDIO_BUFFER_SIZE - (inbuffer_current_position - amAudio_In_BufAddr);

 	if(amAudio_InHandle == -1){
 		LOGE("amAudio_InHandle error: %d\n", -1);
 	}

 	hwptr = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_PTR);
 	if (hwptr == 0xFFFFFFFF)
 		return -1;

 	rdptr = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_RD_PTR);
 	if (rdptr == 0xFFFFFFFF)
 		return -1;

 	Bytes = (hwptr - rdptr + amAudio_InSize) % amAudio_InSize;
 	Bytes = Bytes >> 2 << 2;

 	//LOGD("amAudio in hwptr: %x, rdptr: %x, Bytes: %x, left_size = %x\n", hwptr, rdptr, Bytes,left_size);

 	if (Bytes == 0)
 		return 0;

 	if(hwptr > rdptr){
 		PosBytes = Bytes;
 		if(left_size >= PosBytes){
 			Ret = read (amAudio_InHandle, inbuffer_current_position, PosBytes);
 			if(Ret != PosBytes){
 				LOGE("amAudio_in fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, PosBytes, FileIn);
 #endif
 			inbuffer_current_position += PosBytes;
 			if(left_size == PosBytes){
 				inbuffer_current_position = amAudio_In_BufAddr;
 			}
 		}else{
 			Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
 			if(Ret != left_size){
 				LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, left_size, FileIn);
 #endif
 			inbuffer_current_position = amAudio_In_BufAddr;
 			left_size = PosBytes - left_size;
 			Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
 			if(Ret != left_size){
 				LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, left_size, FileIn);
 #endif
 			inbuffer_current_position = amAudio_In_BufAddr + left_size;
 		}
 	}else{

 		PosBytes = amAudio_InSize - rdptr;

 		if(left_size >= PosBytes){
 			Ret = read (amAudio_InHandle, inbuffer_current_position, PosBytes);
 			if(Ret != PosBytes){
 				LOGE("amAudio_in fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, PosBytes, FileIn);
 #endif
 			inbuffer_current_position += PosBytes;
 			if(left_size == PosBytes)
 				inbuffer_current_position = amAudio_In_BufAddr;
 		}else{
 			Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
 			if(Ret != left_size){
 				LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, left_size, FileIn);
 #endif
 			inbuffer_current_position = amAudio_In_BufAddr;
 			left_size = PosBytes - left_size;
 			Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
 			if(Ret != left_size){
 				LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, left_size, FileIn);
 #endif
 			inbuffer_current_position = amAudio_In_BufAddr + left_size;
 		}

 		PosBytes = Bytes - PosBytes;

 		left_size = AUDIO_BUFFER_SIZE - (inbuffer_current_position - amAudio_In_BufAddr);

 		if(left_size >= PosBytes){
 			Ret = read (amAudio_InHandle, inbuffer_current_position, PosBytes);
 			if(Ret != PosBytes){
 				LOGE("amAudio_in fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, PosBytes, FileIn);
 #endif
 			inbuffer_current_position += PosBytes;
 			if(left_size == PosBytes)
 				inbuffer_current_position = amAudio_In_BufAddr;
 		}else{
 			Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
 			if(Ret != left_size){
 				LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, left_size, FileIn);
 #endif
 			inbuffer_current_position = amAudio_In_BufAddr;
 			left_size = PosBytes - left_size;
 			Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
 			if(Ret != left_size){
 				LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(inbuffer_current_position, 1, left_size, FileIn);
 #endif
 			inbuffer_current_position = amAudio_In_BufAddr + left_size;
 		}

 	}
 	return 0;
 }

 static int amAudio_OutProc(void)
 {
 	int hwptr;
 	int rdptr;
 	int Bytes;
 	int Ret;
 	int PosBytes;
 	int left_size = AUDIO_BUFFER_SIZE - (outbuffer_current_position - amAudio_Out_BufAddr);

 	hwptr = ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_PTR);
 	if (hwptr == 0xFFFFFFFF)
 		return -1;

 	rdptr = ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_RD_PTR);
 	if (rdptr == 0xFFFFFFFF)
 		return -1;

 	Bytes = (hwptr - rdptr + amAudio_OutSize) % amAudio_OutSize;
 	Bytes = Bytes >> 2 << 2;

 	//LOGD("amAudio out hwptr: %x, rdptr: %x, Bytes: %x, left_size = %x, status = %d\n", hwptr, rdptr, Bytes,left_size,(int)Output_buffer_status.status);

 	if (Bytes == 0)
 		return 0;

 	if(hwptr > rdptr)
 		PosBytes = Bytes;
 	else
 		PosBytes = amAudio_OutSize - rdptr;
 	{
 		if(left_size >= PosBytes){
 			Ret = read (amAudio_OutHandle, outbuffer_current_position, PosBytes);
 			if(Ret != PosBytes){
 				LOGE("amAudio_out fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(outbuffer_current_position, 1, PosBytes, FileOut);
 #endif
 			outbuffer_current_position += PosBytes;

 			if (outbuffer_current_position - PosBytes < amAudio_Out_BufAddr_half){
 				if (outbuffer_current_position >= amAudio_Out_BufAddr_half)
 					Output_buffer_status.status = BUFFER1_READY;
 				Output_buffer_status.user_read = amAudio_Out_BufAddr;
 			}
 			else{
 				Output_buffer_status.user_read = amAudio_Out_BufAddr_half;
 			}
 			if(left_size == PosBytes){
 				outbuffer_current_position = amAudio_Out_BufAddr;
 				Output_buffer_status.status |= BUFFER2_READY;
 			}
 		}else{
 			Ret = read (amAudio_OutHandle, outbuffer_current_position, left_size);
 			if(Ret != left_size){
 				LOGE("amAudio_out fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
 				return -1;
 			}
 #ifdef WRITE_AUDIO_OUT_TO_FILE
 			fwrite(outbuffer_current_position, 1, left_size, FileOut);
 #endif
                         if (outbuffer_current_position < amAudio_Out_BufAddr_half){
                                 Output_buffer_status.status = BUFFER1_READY|BUFFER2_READY;
 				Output_buffer_status.user_read = amAudio_Out_BufAddr;
 			}
 			else{
                                 Output_buffer_status.status = BUFFER2_READY;
 				Output_buffer_status.user_read = amAudio_Out_BufAddr_half;
 			}
 			outbuffer_current_position = amAudio_Out_BufAddr;
 		}
 	}
 	return 0;
 }

 static void *amAudio_Thread(void *data)
 {
 	int Ret = 0;
 	int Status = 0;
 	newDataCallback callback = (newDataCallback)data;
 	while (1)
 	{
 		if (amAudio_ThreadExitFlag == 1)
 		{
 			amAudio_ThreadExitFlag = 0;
 			break;
 		}

 		switch (Status)
 		{
 			case 0:
 				//Ret = amAudio_InInit();
 				if (Ret == 0)
 				{
 					Status = 1;
 				}
 				break;
 			case 1:
 				Ret = amAudio_OutInit();
 				if (Ret == 0)
 				{
 					Status = 2;
 				}
 				break;
 			case 2:
 				//Ret = amAudio_InProc();
 				if (Ret == 0)
 				{
 					Status = 3;
 				}else{
 					Status = 0;
 				}
 				break;
 			case 3:
 				Ret = amAudio_OutProc();
 				if (Ret == 0)
 				{
 					Status = 2;
 				}else{
 					Status = 1;
 				}
 				if ((Output_buffer_status.status & BUFFER1_READY)
 					||(Output_buffer_status.status & BUFFER2_READY)){
 					if ((Output_buffer_status.status & BUFFER1_READY)
 	                                	&&(Output_buffer_status.status & BUFFER2_READY))
 						(*callback)(Output_buffer_status.user_read, AUDIO_BUFFER_SIZE);
 					else
 						(*callback)(Output_buffer_status.user_read, AUDIO_BUFFER_SIZE/2);
 					Output_buffer_status.status = NODATA;
 				}
 				break;
 			if(Status == 0 && Status == 1)
 				LOGE("error: new reset!\n");
 		}

 		usleep (M_AUDIO_THREAD_DELAY_TIME);
 	}

 	pthread_exit (0);

 	return ((void*)0);
 }

 static int amAudio_AmlogicInit (newDataCallback callback)
 {
 	pthread_attr_t		attr;
 	struct sched_param	param;
 	int					Ret;

 	/*amAudio_InHandle = open (AUDIO_IN, O_RDWR);
 	if (amAudio_InHandle < 0)
 	{
 		LOGE("The device amaudio_in cant't be opened!\n");
 		return -1;
 	}*/

 	amAudio_OutHandle = -1;
 	while (amAudio_OutHandle < 0){
 		amAudio_OutHandle = open (AUDIO_OUT, O_RDWR);
 		if (amAudio_OutHandle < 0){
 			LOGE("The device amaudio_out cant't be opened!\n");
 			sleep(5);
 		}
 		else{
 			break;
 		}
 		if (amAudio_ThreadExitFlag == 1){
 			amAudio_ThreadExitFlag = 0;
 			return -1;
 		}
 	}

 	//ioctl (amAudio_InHandle, AMAUDIO_IOC_SET_I2S_IN_MODE, 1);
 	ioctl (amAudio_OutHandle, AMAUDIO_IOC_SET_I2S_OUT_MODE, 1);

 	//ioctl (amAudio_InHandle, AMAUDIO_IOC_DIRECT_LEFT_GAIN, 0);
 	//ioctl (amAudio_InHandle, AMAUDIO_IOC_DIRECT_RIGHT_GAIN, 0);

 	/*amAudio_InSize = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_SIZE, 0);
 	LOGI("amAudio_InSize = 0x%x !\n",amAudio_InSize);
 	if (amAudio_InSize == -1)
 	{
 		close (amAudio_OutHandle);
 		amAudio_OutHandle = -1;
 		close (amAudio_InHandle);
 		amAudio_InHandle = -1;
 		return -1;
 	}*/

 	amAudio_OutSize = ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_SIZE, 0);
 	LOGI("amAudio_OutSize = 0x%x !\n",amAudio_OutSize);
 	if (amAudio_OutSize == -1)
 	{
 		close (amAudio_OutHandle);
 		amAudio_OutHandle = -1;
 		//close (amAudio_InHandle);
 		//amAudio_InHandle = -1;
 		return -1;
 	}

 	amAudio_In_BufAddr = (unsigned char *)malloc (AUDIO_BUFFER_SIZE);
 	amAudio_Out_BufAddr = (unsigned char *)malloc (AUDIO_BUFFER_SIZE);

 	/*if (amAudio_In_BufAddr == NULL || amAudio_Out_BufAddr == NULL)
 	{
 		LOGE("Fail to malloc amaudio buffer!\n");
 		close (amAudio_OutHandle);
 		amAudio_OutHandle = -1;
 		close (amAudio_InHandle);
 		amAudio_InHandle = -1;
 		return -1;
 	}*/

 	amAudio_In_BufAddr_half  = amAudio_In_BufAddr + AUDIO_BUFFER_SIZE/2;
 	amAudio_Out_BufAddr_half = amAudio_Out_BufAddr + AUDIO_BUFFER_SIZE/2;
 	Output_buffer_status.status = NODATA;
 	Output_buffer_status.user_read = NULL;

 	pthread_attr_init (&attr);
 	pthread_attr_setschedpolicy (&attr, SCHED_RR);
 	param.sched_priority = sched_get_priority_max (SCHED_RR);
 	pthread_attr_setschedparam (&attr, &param);
 	amAudio_ThreadExitFlag = 0;
 	Ret = pthread_create (&amAudio_ThreadID, &attr, &amAudio_Thread, (void*)callback);
 	pthread_attr_destroy (&attr);

 	if (Ret != 0)
 	{
 		LOGE("Fail to create thread!\n");
 		free(amAudio_In_BufAddr);
 		amAudio_In_BufAddr = NULL;
 		free(amAudio_Out_BufAddr);
 		amAudio_Out_BufAddr = NULL;

 		close (amAudio_OutHandle);
 		amAudio_OutHandle = -1;
 		//close (amAudio_InHandle);
 		//amAudio_InHandle = -1;
 		return -1;
 	}

 	return 0;
 }

 static int amAudio_AmlogicFinish (void)
 {
 	amAudio_ThreadExitFlag = 1;
 	pthread_join(amAudio_ThreadID, NULL);

 	free(amAudio_In_BufAddr);
 	amAudio_In_BufAddr = NULL;

 	free(amAudio_Out_BufAddr);
 	amAudio_Out_BufAddr = NULL;

 	close (amAudio_OutHandle);
 	amAudio_OutHandle = -1;

 	//close (amAudio_InHandle);
 	//amAudio_InHandle = -1;

 	return 0;
 }

 int amAudio_Init(newDataCallback callback)
 {
 	int Ret;

 	LOGI("Audio capture start!\n");

 #ifdef WRITE_AUDIO_OUT_TO_FILE
 	FileIn = fopen ("/mnt/test_in.pcm", "wb");
 	FileOut = fopen ("/mnt/test_out.pcm", "wb");
 	if(FileOut == NULL || FileIn == NULL)
 		LOGE("The file can't be opened!\n");
 #endif

 	Ret = amAudio_AmlogicInit(callback);
 	if (Ret == 0){
 		return 0;
 	}else{
 		amAudio_AmlogicFinish();
 		return -1;
 	}
 }

 int amAudio_Finish (void)
 {
 	amAudio_AmlogicFinish ();

 #ifdef WRITE_AUDIO_OUT_TO_FILE
 	if (FileOut != NULL)
 	{
 		fclose (FileOut);
 		FileOut = NULL;
 	}
 #endif
 	LOGI("Audio capture finish!\n");
 	return 0;
 }

 #ifdef SELF_TEST
 static FILE *pcm_dumpfile = NULL;
 void amAudio_Callback(unsigned char *buf, unsigned len)
 {
 	if (pcm_dumpfile){
 		LOGD("write %x %x to file\n", buf, len);
 		fwrite(buf, len, 1, pcm_dumpfile);
 	}
 }

 int main (void)
 {
 	pcm_dumpfile = fopen("output.pcm","wb");
 	amAudio_Init(&amAudio_Callback);
 	//while (1);
 	sleep(10);
 	amAudio_Finish();
 	if (pcm_dumpfile)
 		fclose(pcm_dumpfile);
 	return 0;
 }
 #endif
	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/poll.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>
	#include <unistd.h>

	#include <pthread.h>
	#include <sys/ioctl.h>
	#include <fcntl.h>

	#include "amAudio.h"

	#define LOG_TAG "amAudio_Test"

	#undef LOGI
	#define LOGI(fmt, ...) printf("I/%s: ", LOG_TAG);printf(fmt, ##__VA_ARGS__);
	#undef LOGE
	#define LOGE(fmt, ...) printf("E/%s: ", LOG_TAG);printf(fmt, ##__VA_ARGS__);
	#undef LOGD
	#define LOGD(fmt, ...) printf("D/%s: ", LOG_TAG);printf(fmt, ##__VA_ARGS__);

	//#define WRITE_AUDIO_OUT_TO_FILE
	#define SELF_TEST

	#define AUDIO_IN "/dev/amaudio_in"
	#define AUDIO_OUT "/dev/amaudio_out"

	#define AMAUDIO_IOC_MAGIC 'A'
	#define AMAUDIO_IOC_GET_I2S_OUT_SIZE _IOW(AMAUDIO_IOC_MAGIC, 0x00, int)
	#define AMAUDIO_IOC_GET_I2S_OUT_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x01, int)
	#define AMAUDIO_IOC_SET_I2S_OUT_RD_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x02, int)
	#define AMAUDIO_IOC_GET_I2S_IN_SIZE _IOW(AMAUDIO_IOC_MAGIC, 0x03, int)
	#define AMAUDIO_IOC_GET_I2S_IN_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x04, int)
	#define AMAUDIO_IOC_SET_I2S_IN_RD_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x05, int)
	#define AMAUDIO_IOC_SET_I2S_IN_MODE _IOW(AMAUDIO_IOC_MAGIC, 0x06, int)
	#define AMAUDIO_IOC_SET_I2S_OUT_MODE _IOW(AMAUDIO_IOC_MAGIC, 0x07, int)
	#define AMAUDIO_IOC_GET_I2S_IN_RD_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x08, int)
	#define AMAUDIO_IOC_GET_I2S_OUT_RD_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x09, int)
	#define AMAUDIO_IOC_SET_I2S_IN_WR_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x0a, int)
	#define AMAUDIO_IOC_SET_I2S_OUT_WR_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x0b, int)
	#define AMAUDIO_IOC_GET_I2S_IN_WR_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x0c, int)
	#define AMAUDIO_IOC_GET_I2S_OUT_WR_PTR _IOW(AMAUDIO_IOC_MAGIC, 0x0d, int)
	#define AMAUDIO_IOC_SET_LEFT_MONO _IOW(AMAUDIO_IOC_MAGIC, 0x0e, int)
	#define AMAUDIO_IOC_SET_RIGHT_MONO _IOW(AMAUDIO_IOC_MAGIC, 0x0f, int)
	#define AMAUDIO_IOC_SET_STEREO _IOW(AMAUDIO_IOC_MAGIC, 0x10, int)
	#define AMAUDIO_IOC_SET_CHANNEL_SWAP _IOW(AMAUDIO_IOC_MAGIC, 0x11, int)
	#define AMAUDIO_IOC_DIRECT_AUDIO _IOW(AMAUDIO_IOC_MAGIC, 0x12, int)
	#define AMAUDIO_IOC_DIRECT_LEFT_GAIN _IOW(AMAUDIO_IOC_MAGIC, 0x13, int)
	#define AMAUDIO_IOC_DIRECT_RIGHT_GAIN _IOW(AMAUDIO_IOC_MAGIC, 0x14, int)

	#define M_AUDIO_THREAD_DELAY_TIME 4000
	#define AUDIO_BUFFER_SIZE 19200

	static int amAudio_InHandle = -1;
	static int amAudio_OutHandle = -1;
	static int amAudio_InSize = -1;
	static int amAudio_OutSize = -1;
	static unsigned char *amAudio_In_BufAddr = NULL;
	static unsigned char *amAudio_Out_BufAddr = NULL;
	unsigned char *inbuffer_current_position = NULL;
	unsigned char *outbuffer_current_position = NULL;

	unsigned char *amAudio_In_BufAddr_half = NULL;
	unsigned char *amAudio_Out_BufAddr_half = NULL;

	static pthread_t amAudio_ThreadID = 0;
	static int amAudio_ThreadExitFlag = 0;

	#define NODATA 0
	#define BUFFER1_READY 1
	#define BUFFER2_READY 2

	typedef struct Buffer_status {
	int status;
	unsigned char *user_read;
	} Buffer_status;

	Buffer_status Output_buffer_status;

	#ifdef WRITE_AUDIO_OUT_TO_FILE
	static FILE *FileIn = NULL;
	static FILE *FileOut = NULL;

	#endif

	static int amAudio_InInit(void)
	{
	unsigned int hwptr;

	hwptr = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_PTR);
	if (hwptr == 0xFFFFFFFF)
	{
	LOGI("amAudio_InInit Error!\n");
	return -1;
	}
	ioctl (amAudio_InHandle, AMAUDIO_IOC_SET_I2S_IN_RD_PTR, hwptr);
	inbuffer_current_position = amAudio_In_BufAddr;
	return 0;
	}

	static int amAudio_OutInit(void)
	{
	unsigned int hwptr;

	hwptr= ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_PTR);
	if (hwptr == 0xFFFFFFFF)
	{
	LOGI("amAudio_OutInit Error!\n");
	return -1;
	}
	ioctl (amAudio_OutHandle, AMAUDIO_IOC_SET_I2S_OUT_RD_PTR, hwptr);
	outbuffer_current_position = amAudio_Out_BufAddr;
	return 0;
	}

	static int amAudio_InProc(void)
	{
	int Ret;
	int hwptr;
	int rdptr;
	int Bytes;
	int PosBytes;
	int left_size = AUDIO_BUFFER_SIZE - (inbuffer_current_position - amAudio_In_BufAddr);

	if(amAudio_InHandle == -1){
	LOGE("amAudio_InHandle error: %d\n", -1);
	}

	hwptr = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_PTR);
	if (hwptr == 0xFFFFFFFF)
	return -1;

	rdptr = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_RD_PTR);
	if (rdptr == 0xFFFFFFFF)
	return -1;

	Bytes = (hwptr - rdptr + amAudio_InSize) % amAudio_InSize;
	Bytes = Bytes >> 2 << 2;

	//LOGD("amAudio in hwptr: %x, rdptr: %x, Bytes: %x, left_size = %x\n", hwptr, rdptr, Bytes,left_size);

	if (Bytes == 0)
	return 0;

	if(hwptr > rdptr){
	PosBytes = Bytes;
	if(left_size >= PosBytes){
	Ret = read (amAudio_InHandle, inbuffer_current_position, PosBytes);
	if(Ret != PosBytes){
	LOGE("amAudio_in fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, PosBytes, FileIn);
	#endif
	inbuffer_current_position += PosBytes;
	if(left_size == PosBytes){
	inbuffer_current_position = amAudio_In_BufAddr;
	}
	}else{
	Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
	if(Ret != left_size){
	LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, left_size, FileIn);
	#endif
	inbuffer_current_position = amAudio_In_BufAddr;
	left_size = PosBytes - left_size;
	Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
	if(Ret != left_size){
	LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, left_size, FileIn);
	#endif
	inbuffer_current_position = amAudio_In_BufAddr + left_size;
	}
	}else{

	PosBytes = amAudio_InSize - rdptr;

	if(left_size >= PosBytes){
	Ret = read (amAudio_InHandle, inbuffer_current_position, PosBytes);
	if(Ret != PosBytes){
	LOGE("amAudio_in fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, PosBytes, FileIn);
	#endif
	inbuffer_current_position += PosBytes;
	if(left_size == PosBytes)
	inbuffer_current_position = amAudio_In_BufAddr;
	}else{
	Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
	if(Ret != left_size){
	LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, left_size, FileIn);
	#endif
	inbuffer_current_position = amAudio_In_BufAddr;
	left_size = PosBytes - left_size;
	Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
	if(Ret != left_size){
	LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, left_size, FileIn);
	#endif
	inbuffer_current_position = amAudio_In_BufAddr + left_size;
	}

	PosBytes = Bytes - PosBytes;

	left_size = AUDIO_BUFFER_SIZE - (inbuffer_current_position - amAudio_In_BufAddr);

	if(left_size >= PosBytes){
	Ret = read (amAudio_InHandle, inbuffer_current_position, PosBytes);
	if(Ret != PosBytes){
	LOGE("amAudio_in fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, PosBytes, FileIn);
	#endif
	inbuffer_current_position += PosBytes;
	if(left_size == PosBytes)
	inbuffer_current_position = amAudio_In_BufAddr;
	}else{
	Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
	if(Ret != left_size){
	LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, left_size, FileIn);
	#endif
	inbuffer_current_position = amAudio_In_BufAddr;
	left_size = PosBytes - left_size;
	Ret = read (amAudio_InHandle, inbuffer_current_position, left_size);
	if(Ret != left_size){
	LOGE("amAudio_in fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(inbuffer_current_position, 1, left_size, FileIn);
	#endif
	inbuffer_current_position = amAudio_In_BufAddr + left_size;
	}

	}
	return 0;
	}

	static int amAudio_OutProc(void)
	{
	int hwptr;
	int rdptr;
	int Bytes;
	int Ret;
	int PosBytes;
	int left_size = AUDIO_BUFFER_SIZE - (outbuffer_current_position - amAudio_Out_BufAddr);

	hwptr = ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_PTR);
	if (hwptr == 0xFFFFFFFF)
	return -1;

	rdptr = ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_RD_PTR);
	if (rdptr == 0xFFFFFFFF)
	return -1;

	Bytes = (hwptr - rdptr + amAudio_OutSize) % amAudio_OutSize;
	Bytes = Bytes >> 2 << 2;

	//LOGD("amAudio out hwptr: %x, rdptr: %x, Bytes: %x, left_size = %x, status = %d\n", hwptr, rdptr, Bytes,left_size,(int)Output_buffer_status.status);

	if (Bytes == 0)
	return 0;

	if(hwptr > rdptr)
	PosBytes = Bytes;
	else
	PosBytes = amAudio_OutSize - rdptr;
	{
	if(left_size >= PosBytes){
	Ret = read (amAudio_OutHandle, outbuffer_current_position, PosBytes);
	if(Ret != PosBytes){
	LOGE("amAudio_out fail to read! Ret = %d, PosBytes = %d \n",Ret, PosBytes);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(outbuffer_current_position, 1, PosBytes, FileOut);
	#endif
	outbuffer_current_position += PosBytes;

	if (outbuffer_current_position - PosBytes < amAudio_Out_BufAddr_half){
	if (outbuffer_current_position >= amAudio_Out_BufAddr_half)
	Output_buffer_status.status = BUFFER1_READY;
	Output_buffer_status.user_read = amAudio_Out_BufAddr;
	}
	else{
	Output_buffer_status.user_read = amAudio_Out_BufAddr_half;
	}
	if(left_size == PosBytes){
	outbuffer_current_position = amAudio_Out_BufAddr;
	Output_buffer_status.status \|= BUFFER2_READY;
	}
	}else{
	Ret = read (amAudio_OutHandle, outbuffer_current_position, left_size);
	if(Ret != left_size){
	LOGE("amAudio_out fail to read! Ret = %d, left_size = %d \n",Ret, left_size);
	return -1;
	}
	#ifdef WRITE_AUDIO_OUT_TO_FILE
	fwrite(outbuffer_current_position, 1, left_size, FileOut);
	#endif
	if (outbuffer_current_position < amAudio_Out_BufAddr_half){
	Output_buffer_status.status = BUFFER1_READY\|BUFFER2_READY;
	Output_buffer_status.user_read = amAudio_Out_BufAddr;
	}
	else{
	Output_buffer_status.status = BUFFER2_READY;
	Output_buffer_status.user_read = amAudio_Out_BufAddr_half;
	}
	outbuffer_current_position = amAudio_Out_BufAddr;
	}
	}
	return 0;
	}

	static void amAudio_Thread(void data)
	{
	int Ret = 0;
	int Status = 0;
	newDataCallback callback = (newDataCallback)data;
	while (1)
	{
	if (amAudio_ThreadExitFlag == 1)
	{
	amAudio_ThreadExitFlag = 0;
	break;
	}

	switch (Status)
	{
	case 0:
	//Ret = amAudio_InInit();
	if (Ret == 0)
	{
	Status = 1;
	}
	break;
	case 1:
	Ret = amAudio_OutInit();
	if (Ret == 0)
	{
	Status = 2;
	}
	break;
	case 2:
	//Ret = amAudio_InProc();
	if (Ret == 0)
	{
	Status = 3;
	}else{
	Status = 0;
	}
	break;
	case 3:
	Ret = amAudio_OutProc();
	if (Ret == 0)
	{
	Status = 2;
	}else{
	Status = 1;
	}
	if ((Output_buffer_status.status & BUFFER1_READY)
	\|\|(Output_buffer_status.status & BUFFER2_READY)){
	if ((Output_buffer_status.status & BUFFER1_READY)
	&&(Output_buffer_status.status & BUFFER2_READY))
	(*callback)(Output_buffer_status.user_read, AUDIO_BUFFER_SIZE);
	else
	(*callback)(Output_buffer_status.user_read, AUDIO_BUFFER_SIZE/2);
	Output_buffer_status.status = NODATA;
	}
	break;
	if(Status == 0 && Status == 1)
	LOGE("error: new reset!\n");
	}

	usleep (M_AUDIO_THREAD_DELAY_TIME);
	}

	pthread_exit (0);

	return ((void*)0);
	}

	static int amAudio_AmlogicInit (newDataCallback callback)
	{
	pthread_attr_t attr;
	struct sched_param param;
	int Ret;

	/*amAudio_InHandle = open (AUDIO_IN, O_RDWR);
	if (amAudio_InHandle < 0)
	{
	LOGE("The device amaudio_in cant't be opened!\n");
	return -1;
	}*/

	amAudio_OutHandle = -1;
	while (amAudio_OutHandle < 0){
	amAudio_OutHandle = open (AUDIO_OUT, O_RDWR);
	if (amAudio_OutHandle < 0){
	LOGE("The device amaudio_out cant't be opened!\n");
	sleep(5);
	}
	else{
	break;
	}
	if (amAudio_ThreadExitFlag == 1){
	amAudio_ThreadExitFlag = 0;
	return -1;
	}
	}

	//ioctl (amAudio_InHandle, AMAUDIO_IOC_SET_I2S_IN_MODE, 1);
	ioctl (amAudio_OutHandle, AMAUDIO_IOC_SET_I2S_OUT_MODE, 1);

	//ioctl (amAudio_InHandle, AMAUDIO_IOC_DIRECT_LEFT_GAIN, 0);
	//ioctl (amAudio_InHandle, AMAUDIO_IOC_DIRECT_RIGHT_GAIN, 0);

	/*amAudio_InSize = ioctl (amAudio_InHandle, AMAUDIO_IOC_GET_I2S_IN_SIZE, 0);
	LOGI("amAudio_InSize = 0x%x !\n",amAudio_InSize);
	if (amAudio_InSize == -1)
	{
	close (amAudio_OutHandle);
	amAudio_OutHandle = -1;
	close (amAudio_InHandle);
	amAudio_InHandle = -1;
	return -1;
	}*/

	amAudio_OutSize = ioctl (amAudio_OutHandle, AMAUDIO_IOC_GET_I2S_OUT_SIZE, 0);
	LOGI("amAudio_OutSize = 0x%x !\n",amAudio_OutSize);
	if (amAudio_OutSize == -1)
	{
	close (amAudio_OutHandle);
	amAudio_OutHandle = -1;
	//close (amAudio_InHandle);
	//amAudio_InHandle = -1;
	return -1;
	}

	amAudio_In_BufAddr = (unsigned char *)malloc (AUDIO_BUFFER_SIZE);
	amAudio_Out_BufAddr = (unsigned char *)malloc (AUDIO_BUFFER_SIZE);

	/*if (amAudio_In_BufAddr == NULL \|\| amAudio_Out_BufAddr == NULL)
	{
	LOGE("Fail to malloc amaudio buffer!\n");
	close (amAudio_OutHandle);
	amAudio_OutHandle = -1;
	close (amAudio_InHandle);
	amAudio_InHandle = -1;
	return -1;
	}*/

	amAudio_In_BufAddr_half = amAudio_In_BufAddr + AUDIO_BUFFER_SIZE/2;
	amAudio_Out_BufAddr_half = amAudio_Out_BufAddr + AUDIO_BUFFER_SIZE/2;
	Output_buffer_status.status = NODATA;
	Output_buffer_status.user_read = NULL;

	pthread_attr_init (&attr);
	pthread_attr_setschedpolicy (&attr, SCHED_RR);
	param.sched_priority = sched_get_priority_max (SCHED_RR);
	pthread_attr_setschedparam (&attr, &param);
	amAudio_ThreadExitFlag = 0;
	Ret = pthread_create (&amAudio_ThreadID, &attr, &amAudio_Thread, (void*)callback);
	pthread_attr_destroy (&attr);

	if (Ret != 0)
	{
	LOGE("Fail to create thread!\n");
	free(amAudio_In_BufAddr);
	amAudio_In_BufAddr = NULL;
	free(amAudio_Out_BufAddr);
	amAudio_Out_BufAddr = NULL;

	close (amAudio_OutHandle);
	amAudio_OutHandle = -1;
	//close (amAudio_InHandle);
	//amAudio_InHandle = -1;
	return -1;
	}

	return 0;
	}

	static int amAudio_AmlogicFinish (void)
	{
	amAudio_ThreadExitFlag = 1;
	pthread_join(amAudio_ThreadID, NULL);

	free(amAudio_In_BufAddr);
	amAudio_In_BufAddr = NULL;

	free(amAudio_Out_BufAddr);
	amAudio_Out_BufAddr = NULL;

	close (amAudio_OutHandle);
	amAudio_OutHandle = -1;

	//close (amAudio_InHandle);
	//amAudio_InHandle = -1;

	return 0;
	}

	int amAudio_Init(newDataCallback callback)
	{
	int Ret;

	LOGI("Audio capture start!\n");

	#ifdef WRITE_AUDIO_OUT_TO_FILE
	FileIn = fopen ("/mnt/test_in.pcm", "wb");
	FileOut = fopen ("/mnt/test_out.pcm", "wb");
	if(FileOut == NULL \|\| FileIn == NULL)
	LOGE("The file can't be opened!\n");
	#endif

	Ret = amAudio_AmlogicInit(callback);
	if (Ret == 0){
	return 0;
	}else{
	amAudio_AmlogicFinish();
	return -1;
	}
	}

	int amAudio_Finish (void)
	{
	amAudio_AmlogicFinish ();

	#ifdef WRITE_AUDIO_OUT_TO_FILE
	if (FileOut != NULL)
	{
	fclose (FileOut);
	FileOut = NULL;
	}
	#endif
	LOGI("Audio capture finish!\n");
	return 0;
	}

	#ifdef SELF_TEST
	static FILE *pcm_dumpfile = NULL;
	void amAudio_Callback(unsigned char *buf, unsigned len)
	{
	if (pcm_dumpfile){
	LOGD("write %x %x to file\n", buf, len);
	fwrite(buf, len, 1, pcm_dumpfile);
	}
	}

	int main (void)
	{
	pcm_dumpfile = fopen("output.pcm","wb");
	amAudio_Init(&amAudio_Callback);
	//while (1);
	sleep(10);
	amAudio_Finish();
	if (pcm_dumpfile)
	fclose(pcm_dumpfile);
	return 0;
	}
	#endif