parse_audio_cmdline.c

1. 8623L平台

	options->mclk = MClkFactor_256Xfs;
	
	options->chconfig=2;
	options->drcenable=1;
	options->drcboost=100;
	options->drccut=100;
	options->drcdialref=-31;
	options->lossless=FALSE;
	options->audio_play_time.PlayMode = 0;
	options->audio_play_time.PlayStartPTS = 0;
	options->audio_play_time.PlayEndPTS = 0;	
	
	options->ppdmx = FALSE;
	options->centerup = FALSE;
	
	options->PL2xParams.mode = 3;
	options->PL2xParams.a = 0;
	options->PL2xParams.f = 0;
	options->PL2xParams.r = 0;
	options->PL2xParams.t = 0;
	options->PL2xParams.w = 3;
	options->PL2xParams.d = 7;
	options->PL2xParams.x = 0;
	options->PL2xParams.on = 0;
	options->PL2xParams.autoEX = 0;
	
	options->i2s_spdif = 0;
	
	options->spdifChannelStatus.Mask = 0;   
	options->spdifChannelStatus.Value = 0;
	
	options->mute_enable = FALSE;
	options->ChannelDelay.Delay_ch0 = 0;
	options->ChannelDelay.Delay_ch1 = 0;
	options->ChannelDelay.Delay_ch2 = 0;
	options->ChannelDelay.Delay_ch3 = 0;
	options->ChannelDelay.Delay_ch4 = 0;
	options->ChannelDelay.Delay_ch5 = 0;
	options->ChannelDelay.Delay_ch6 = 0;
	options->ChannelDelay.Delay_ch7 = 0;
	options->mute_gpio = 0;
	options->mute_polarity = FALSE;
	options->thisAudioInstance = 0;
	options->audioInstances = 1;
	options->cdmx_enable = FALSE;
	options->sync_stc = TRUE;
	
	//default disable dumpchannel
	options->dumpchannel = 0;
	options->dumpchannelbw=16;
	options->dumpchannelen = 0;
	
	
	options->KaraokeMode = KaraokeMode_Mix;
	return RM_OK;
}

//Now we use MAX 8 channel but will increase to 12 in future
#define MAX_CHANNEL  8  
#define MAX_FIFO_SIZE options->captureFifoSize * MAX_CHANNEL

RMuint32 audio_dump_getFullness(struct audio_cmdline *options, struct dcc_context *dcc_info)
{
	struct _captureContainer* container = (struct _captureContainer*)options->captureContainer;
	RMuint32 rPtr = container->rPtr;
	RMuint32 wPtr = container->wPtr0;
	//Allocate a temporary FIFO to save data for 32bit ==> 16 bit/24 bit conversion
	if(rPtr <= wPtr) {
	 RMDBGLOG((DISABLE, "\n\n r(0x%x) w(0x%x) L(%d)\n", (RMuint32)rPtr, (RMuint32)wPtr,(RMuint32)(wPtr-rPtr)));
	 return (wPtr-rPtr);
	}
	else {
	 RMDBGLOG((DISABLE, "\n\n r(0x%x) w(0x%x) L(%d)\n", (RMuint32)rPtr, (RMuint32)wPtr,(RMuint32)(options->captureFifoSize-(rPtr-wPtr))));
	 return (RMuint32)(options->captureFifoSize-(rPtr-wPtr));
	}
}


static RMuint32 ConvertPP(int format,RMuint32 datasize, RMuint8* pcmbuf, RMbool e)
{
	RMuint32 tmp=0;
	RMuint32 i=0,k=0;
	
	
	for(i=0,k=0;k<datasize;k+=4)
	{
	  //16 bits sampel capture	
	  if(format ==16){
//	  	fprintf(stderr,"\n\n k(%d)\n\n",(unsigned int)k);	
		memcpy(&tmp,pcmbuf+k,4);
		tmp = e? ((tmp>>8) &0xffff):(((tmp >> 8) & 0xff)<<8) | (((tmp >> 8) & 0xff00)>>8);
		memcpy(pcmbuf+i,&tmp,2);
		i+=2;
	  }
	  
	  //24 bits sampel capture
	  if(format ==24){	
		memcpy(&tmp,pcmbuf+k,4);
		tmp = e?((tmp >> 8) & 0xffffff) : \
			(((tmp >>8) & 0xff) <<16 |((tmp >>16) & 0xff) <<8 | ((tmp>>24) & 0xff)) ;
		memcpy(pcmbuf+i,&tmp,3);
		i+=3;
	  }
	}
	return 0;
}
		
		
static RMuint32 MergeFile(int format,int opt,RMuint32 datasize,RMuint8* tmpbuf[],struct audio_cmdline *options)
{
		RMuint32 j;
		RMuint32 vsize = (format==16)?(datasize /2) : (datasize *3/4);
		RMuint32 inc   = (format==16)?2:3;
		
		for(j=0; j<vsize; j+=inc)
		{
		  if(opt==2)
		  {	
			fwrite(tmpbuf[0]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[1]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
		  }	
		  if(opt==1)
		  {
			fwrite(tmpbuf[1]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[3]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[2]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[6]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[4]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[5]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[7]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
			fwrite(tmpbuf[8]+j, sizeof(char),inc,(FILE*)options->capture_fp[12]);
		  }	
		}
	return 0;	
}
static RMuint8* PP_tmpbuf[MAX_CHANNEL]={0};
RMstatus audio_dump_channel(struct audio_cmdline *options, struct dcc_context *dcc_info)
{
	//Assume you have called open_capture_fifo
	RMuint32 fullness = audio_dump_getFullness(options,dcc_info);
	struct _captureContainer* container = (struct _captureContainer*)options->captureContainer ;
	
	//fprintf(stderr, "\n\n startFifo at: 0x%x\n", (unsigned int)options->captureFifo);
	
	RMuint32 rPtr = container->rPtr;
	RMuint32 wPtr = container->wPtr0;
	
	RMuint32 i=0,offset=0;

	

	if(fullness>0)
	{
	   for(i=0,offset=0;i<MAX_CHANNEL;i++,offset+=options->captureFifoSize) 
	   {
		     memset(PP_tmpbuf[i],0,options->captureFifoSize);
		     if(wPtr > rPtr)
		     {
			   memcpy(PP_tmpbuf[i], (RMuint8*)((RMuint32)options->captureFifo+rPtr+offset),fullness);
		     }
		     else
		     {
			   memcpy(PP_tmpbuf[i],(RMuint8*)((RMuint32)options->captureFifo+rPtr+offset),options->captureFifoSize-rPtr);
			   memcpy((RMuint8*)(PP_tmpbuf[i]+options->captureFifoSize-rPtr), (RMuint8*)((RMuint32)options->captureFifo+offset),wPtr);
		     }


			
			ConvertPP(options->dumpchannelbw,fullness, PP_tmpbuf[i],options->dumpchannelen);
			fwrite(PP_tmpbuf[i],1,			       (options->dumpchannelbw==16)?(fullness/2):(fullness*3/4),			       (FILE*)options->capture_fp[i]);
	}
      	   rPtr = (rPtr + fullness) % options->captureFifoSize;
	   container->rPtr=rPtr; //Update Read Pointer each time
	   MergeFile(options->dumpchannelbw,options->dumpchannel ,fullness,PP_tmpbuf,options);
		     

	}
	return RM_OK;
}



RMstatus open_capture_fifo(struct audio_cmdline *options, struct dcc_context *dcc_info)
{
	//Hard wired to allocate the fifo
	RMstatus err=RM_OK;
	RMuint32 capture_container_hwaddr=0;
	struct _captureContainer* tmp=NULL;
	RMbool cstate=FALSE;
	RMuint32 i;
	
	err = RUAGetProperty(dcc_info->pRUA, 
				EMHWLIB_MODULE(AudioEngine, options->AudioEngineID), 
				RMAudioEnginePropertyID_audio_captureFifo_info, 
				&(options->captureFifoSize), sizeof(RMuint32));
	
	//Use double size as Audio PP Fifo to ensure we have enough spaces to capture
	options->captureFifoSize *=2; 
	
	//Container Allocation+fifo allocation
	capture_container_hwaddr= RUAMalloc(dcc_info->pRUA,0, RUA_DRAM_UNPROTECTED, sizeof(struct _captureContainer) + MAX_FIFO_SIZE);
	if(!capture_container_hwaddr) {
                RMDBGLOG((ENABLE, " RUAmalloc failed %d\n", err ));
                return err;
        }
	
	err = RUALock(dcc_info->pRUA,capture_container_hwaddr,sizeof(struct _captureContainer)+MAX_FIFO_SIZE);
	if(RMFAILED(err)) {
                RMDBGLOG((ENABLE, " RUALock failed %d\n", err ));
                return err;
        }
	options->captureContainer=RUAMap(dcc_info->pRUA,capture_container_hwaddr,sizeof(struct _captureContainer)+MAX_FIFO_SIZE);
	
	memset(options->captureContainer,0,sizeof(struct _captureContainer)+MAX_FIFO_SIZE);
	
	if(!options->captureContainer) {
                RMDBGLOG((ENABLE, " \n\nRUAmap failed %d\n\n\n", err ));
                return err;
        }
#if 1
	//Configure the Hardware Fifo Address
	tmp = (struct _captureContainer*)options->captureContainer ;
	tmp->start =(RMuint32)capture_container_hwaddr+sizeof(struct _captureContainer);
	tmp->size =MAX_FIFO_SIZE / MAX_CHANNEL;
	tmp->rPtr =0x0;
	options->captureContainer_hwaddr = capture_container_hwaddr;
	options->captureFifo = (RMuint32)options->captureContainer + sizeof(struct _captureContainer);
	

	err = RUASetProperty(dcc_info->pRUA, 
				EMHWLIB_MODULE(AudioEngine, options->AudioEngineID), 
				RMAudioEnginePropertyID_audio_captureFifo_container, 
				&(options->captureContainer_hwaddr), sizeof(RMuint32),0);
	
	cstate=TRUE;
	err = RUASetProperty(dcc_info->pRUA, 
					EMHWLIB_MODULE(AudioEngine, options->AudioEngineID), 
					RMAudioEnginePropertyID_AudioSampleDump, 
					&(cstate), sizeof(RMbool),0);
				
				
	
	//options->captureFifoSize = 0x10000;			
		
	//Open capture File hander
	options->capture_fp[0] =  (RMuint64*)fopen("pcmL.dat", "w+b");
	if(!options->capture_fp[0])
	  fprintf(stderr,"\n\nFile Open error");
	options->capture_fp[1] =  (RMuint64*)fopen("pcmR.dat", "w+b");
	options->capture_fp[2] =  (RMuint64*)fopen("pcmC.dat", "w+b");
	options->capture_fp[3] =  (RMuint64*)fopen("pcmLFE.dat", "w+b");
	options->capture_fp[4] =  (RMuint64*)fopen("pcmLs.dat", "w+b");
	options->capture_fp[5] =  (RMuint64*)fopen("pcmRs.dat", "w+b");
	options->capture_fp[6] =  (RMuint64*)fopen("pcmLss.dat", "w+b");
	options->capture_fp[7] =  (RMuint64*)fopen("pcmRss.dat", "w+b");
	/* For future Channel captures  */
	options->capture_fp[8] =  (RMuint64*)fopen("pcm_undef1.dat", "w+b");
	options->capture_fp[9] =  (RMuint64*)fopen("pcm_undef2.dat", "w+b");
	options->capture_fp[10] = (RMuint64*)fopen("pcm_undef3.dat", "w+b");
	options->capture_fp[11] = (RMuint64*)fopen("pcm_undef4.dat", "w+b");
	/* For Merged Channel Data */
	options->capture_fp[12] = (RMuint64*)fopen("merge.dat", "w+b");
	
		


#endif
	for(i=0;i<MAX_CHANNEL;i++) 
 	  PP_tmpbuf[i]=malloc(options->captureFifoSize);

	return RM_OK;
}

RMstatus close_capture_fifo(struct audio_cmdline *options, struct dcc_context *dcc_info)
{
	
	RMuint32 i=0,k=0;
	RUAUnMap( dcc_info->pRUA, options->captureContainer, sizeof(struct _captureContainer)+MAX_FIFO_SIZE);
        RUAUnLock(dcc_info->pRUA, options->captureContainer_hwaddr, sizeof(struct _captureContainer)+MAX_FIFO_SIZE);
        
	for(i=0;i<MAX_CHANNEL;i++) 
	   {
		if(PP_tmpbuf[i]) 
		   free(PP_tmpbuf[i]);
	   }
	
	for(k=0;k<13;k++)
	 if(options->capture_fp[k])
	 fclose((FILE*)options->capture_fp[k]);
	return RM_OK;
}




RMstatus parse_audio_cmdline(int argc, char **argv, int *index, struct audio_cmdline *options)
{
	RMstatus err = RM_PENDING;
	int i = *index;
	
	if ( ! strcmp(argv[i], "-afs")) {
		if (argc > i+1) {
			options->AudioFreqFromStream = strtol(argv[i+1], NULL, 10);
			i+=2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if ( ! strcmp(argv[i], "-ae")) {
		if (argc > i+1) {
			options->AudioEngineID = strtol(argv[i+1], NULL, 10);
			i+=2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if ( ! strcmp(argv[i], "-ad")) {
		if (argc > i+1) {
			options->AudioDecoderID = strtol(argv[i+1], NULL, 10);
			i+=2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	} else if ( ! strcmp(argv[i], "-chan")) {
		if (argc > i+1) {
			
			options->OutputChannels =  get_channel_mask(argv[i+1]);
			
			options->OutputChannelsExplicitAssign = TRUE;
			
			i += 2;
			err = RM_OK;
		} else
			err = RM_ERROR;
	} else if (! strcmp(argv[i], "-ac3compmode")) {
		if (argc > i+1) {
			options->Ac3Params.CompMode = (enum Ac3CompMode_type)atoi(argv[i+1]);
			i+=2;
			err = RM_OK;
		} else 
			err = RM_ERROR;
	} else if (! strcmp(argv[i], "-ac3dynhi")) {
		if (argc > i+1) {
			RMuint32 dynhi;
			sscanf((const char*)argv[i+1], (const char*)"0x%08lx", &dynhi);
			options->Ac3Params.DynScaleHi = dynhi;
			i += 2;
			err = RM_OK;
		} else
			err = RM_ERROR;
	} else if (! strcmp(argv[i], "-ac3dynlo")) {
		if (argc > i+1) {
			RMuint32 dynlo;
			sscanf((const char*)argv[i+1], (const char*)"0x%08lx", &dynlo);
			options->Ac3Params.DynScaleLo = dynlo;
			i += 2;
			err = RM_OK;
		} else
			err = RM_ERROR;
	} else if (! strcmp(argv[i], "-ac3pcmscale")) {
		if (argc > i+1) {
			RMuint32 PcmScale;
			sscanf((const char*)argv[i+1], (const char*)"0x%08lx", &PcmScale);
			options->Ac3Params.PcmScale = PcmScale;
			i += 2;
			err = RM_OK;
		} else
			err = RM_ERROR;
	} else if (! strcmp(argv[i], "-ttone_type")){
		if(argc > i+1) {
			RMuint32 ttone_type;
			sscanf((const char*)argv[i+1], (const char*)"0x%lx", &ttone_type);
			options->TToneParams.TToneType = ttone_type;
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (! strcmp(argv[i], "-ttone_mask")){
		if(argc > i+1) {
			RMuint32 ttone_chmask;
			sscanf((const char*)argv[i+1], (const char*)"0x%lx", &ttone_chmask);
			options->TToneParams.TToneChannelMask = ttone_chmask;
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (! strcmp(argv[i], "-c")) {
		if (argc > i+1) {