parse_audio_cmdline.c

1. 8623L平台

			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-axfer")) {
		if (argc > i+1) {
			RMasciiToUInt32(argv[i+1], &(options->xfer_count));
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-askip_first_n_bytes")) {
		if (argc > i+1) {
			RMasciiToUInt32(argv[i+1], &(options->skip_first_n_bytes));
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-asend_n_bytes")) {
		if (argc > i+1) {
			RMasciiToUInt32(argv[i+1], &(options->send_n_bytes));
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-rclkmclk")) {
		if (argc > i+1) {
			RMuint32 n;
			RMasciiToUInt32(argv[i+1], &n);
			options->mclk_on_rclk = (enum ClockSignal)(ClockSignal_RClk0 + n);
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-audio_cp")) {
		options->AudioCP = TRUE;
		i++;
		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-channel_status")) {
		if (argc > i+2) {
			RMuint32 mask;
			RMuint32 value;
			
			RMasciiToUInt32(argv[i+1], &mask);
			RMDBGLOG((LOCALDBG, "***SPDIF*** MASK = 0x%08x\n", mask));
			
			RMasciiToUInt32(argv[i+2], &value);
			RMDBGLOG((LOCALDBG, "***SPDIF*** VALUE = 0x%08x\n", value));
			
			options->spdifChannelStatus.Mask = mask;
			options->spdifChannelStatus.Value = value;		
			
			i += 3;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-mclk")) {
		if (argc > i+1) {
			RMuint32 n;
			RMasciiToUInt32(argv[i+1], &n);
			options->mclk = (n == 128) ? MClkFactor_128Xfs : MClkFactor_256Xfs;
			i += 2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-audio_hdmi2c")) {
		fprintf(stderr, "WARNING: -audio_hdmi2c is OBSOLETE. Do not use it anymore.\n");
		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-mute")) {
		if (argc > i + 2) {
			RMuint32 gpio;
			options->mute_enable = TRUE;
			RMasciiToUInt32(argv[i+1], &gpio);
			options->mute_gpio = (enum GPIOId_type)gpio;
			options->mute_polarity = ((argv[i+2][0]=='1')||(argv[i+2][0]=='h')||(argv[i+2][0]=='H'));
			i += 3;
			err = RM_OK;
		}
		else err = RM_ERROR;
	}
	else if (RMCompareAscii(argv[i], "-audio_hdmi_ddc_tx")) {
		fprintf(stderr, "WARNING: -audio_hdmi_ddc_tx is OBSOLETE. Do not use it anymore.\n");
		err = RM_OK;
	}
	else if ( ! strcmp(argv[i], "-dumpch")) {
		if (argc > i+3) {
			options->dumpchannel = strtol(argv[i+1], NULL, 10);
			options->dumpchannelbw = strtol(argv[i+2], NULL, 10);
			options->dumpchannelen = strtol(argv[i+3], NULL, 10);
			i += 4;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	} 
	
	*index = i;
	
	//RMDBGLOG((LOCALDBG, ">>>>>>>>>>>>Cmdline Speaker Configure = %0x\n", options->OutputChannels));
	
	return err;
}



RMstatus init_audio_options2(struct audio_cmdline options[], RMuint32 entries)
{
	RMuint32 i;
	
	for (i = 0; i < entries; i++) {
		RMDBGLOG((LOCALDBG, "set default options for instance %lu (@0x%lx)\n", i, (RMuint32)(options + i)));
		
		init_audio_options( (options + i) );
		
		options[i].thisAudioInstance = i; // this, while handy, forces you to be carefull when copying this data structure...
		options[i].audioInstances = 1;
	}
	
	return RM_OK;
}

RMstatus print_parsed_audio_options(struct audio_cmdline options[])
{
	RMuint32 instances = options[0].audioInstances;
	RMuint32 i;
	
	RMDBGPRINT((ENABLE, "print_parsed_audio_options\n"));
	
	for (i = 0; i < instances; i++) {
		RMDBGPRINT((ENABLE, "audio options for instance %lu (id %lu, total %lu)\n", i, options[i].thisAudioInstance, options[i].audioInstances));
		RMDBGPRINT((ENABLE, "\tengine 0x%lx %s\n", options[i].AudioEngineID, options[i].AudioEngineID == DEFAULT_ENGINE ? "(default)":""));
		
		RMDBGPRINT((ENABLE, "\tdecoder 0x%lx %s\n", options[i].AudioDecoderID, options[i].AudioDecoderID == DEFAULT_DECODER ? "(default)":""));
		
		RMDBGPRINT((ENABLE, "fifo size %lu\n", options[i].fifo_size));
		RMDBGPRINT((ENABLE, "fifo count %lu\n", options[i].xfer_count));
		
		RMDBGPRINT((ENABLE, "\tcodec 0x%lx %s\n", options[i].Codec, options[i].Codec == DEFAULT_CODEC ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tsubCodec 0x%lx %s\n", options[i].SubCodec, options[i].SubCodec == DEFAULT_SUBCODEC ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tsampleRate 0x%lx (%lu) %s\n", options[i].SampleRate, options[i].SampleRate, options[i].SampleRate == DEFAULT_SAMPLE_RATE ? "(default)":""));
		
		RMDBGPRINT((ENABLE, "\tsamplingFreq 0x%lx %s\n", options[i].SamplingFrequency, options[i].SamplingFrequency == DEFAULT_SAMPLING_FREQ ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tforceSampleRate 0x%lx %s\n", options[i].ForceSampleRate, options[i].ForceSampleRate == DEFAULT_FORCE_SAMPLE_RATE ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tcaptureSource 0x%lx %s\n", options[i].CaptureSource, options[i].CaptureSource == DEFAULT_CAPTURE_SOURCE ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tcaptureBitstream 0x%lx %s\n", options[i].CaptureBitstream, options[i].CaptureBitstream == DEFAULT_CAPTURE_BITSTREAM ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tcaptureType 0x%lx %s\n", options[i].CaptureType, options[i].CaptureType == DEFAULT_CAPTURE_TYPE ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tcaptureDelay 0x%lx %s\n", options[i].CaptureDelay, options[i].CaptureDelay == DEFAULT_CAPTURE_DELAY ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tserialOut 0x%lx %s\n", options[i].SerialOut, options[i].SerialOut == DEFAULT_SERIAL_OUT ? "(default)":""));
		RMDBGPRINT((ENABLE, "\texternalClk 0x%lx %s\n", options[i].ExternalClk, options[i].ExternalClk == DEFAULT_EXTERNAL_CLK ? "(default)":""));
		RMDBGPRINT((ENABLE, "\taudioIn 0x%lx %s\n", options[i].AudioIn, options[i].AudioIn == DEFAULT_AUDIO_IN ? "(default)":""));
		RMDBGPRINT((ENABLE, "\taudioInAlign 0x%lx %s\n", options[i].AudioInAlign, options[i].AudioInAlign == DEFAULT_AUDIO_IN_ALIGN ? "(default)":""));
		RMDBGPRINT((ENABLE, "\taudioInLSBFirst 0x%lx %s\n", options[i].AudioInLSBfirst, options[i].AudioInLSBfirst == DEFAULT_AUDIO_IN_LSB_FIRST ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tI2SAlign 0x%lx %s\n", options[i].I2SAlign, options[i].I2SAlign == DEFAULT_I2S_ALIGN ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tI2SSClkNormal 0x%lx %s\n", options[i].I2SSClkNormal, options[i].I2SSClkNormal == DEFAULT_I2S_SCLK_NORMAL ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tI2SFrameNormal 0x%lx %s\n", options[i].I2SFrameNormal, options[i].I2SFrameNormal == DEFAULT_I2S_FRAME_NORMAL ? "(default)":""));
		RMDBGPRINT((ENABLE, "\tI2SLSBFirst 0x%lx %s\n", options[i].I2SLSBFirst, options[i].I2SLSBFirst == DEFAULT_I2S_LSB_FIRST ? "(default)":""));
	}
	return RM_OK;
}

/* *****************************
   this api will soon change to:
   RMstatus parse_audio_cmdline(int argc, char **argv, int *index, struct audio_cmdline *options, RMuint32 optionsCount, RMuint32 *currentInstance)
*/

RMstatus parse_audio_cmdline2(int argc, char **argv, int *index, struct audio_cmdline options[], RMuint32 optionsCount, RMuint32 *currentInstance)
{
	RMstatus err = RM_PENDING;
	int i = *index;
	
	RMDBGLOG((DISABLE, "parsing option[%lu]='%s'\n", i, argv[i]));
	
	if ( ! strcmp(argv[i], "-audio_instance")) {
		if (argc > i+1) {
			RMuint32 instance;
			
			instance = strtol(argv[i+1], NULL, 10);
			i += 2;
			
			if (*currentInstance != instance) {
				RMuint32 j, totalInstances;
				
				totalInstances = options[0].audioInstances;
				totalInstances++;
				
				if (totalInstances > optionsCount)
					err = RM_ERROR;
				else {
					for (j = 0; j < totalInstances; j++)
						options[j].audioInstances = totalInstances;
					
					*currentInstance = instance;
					RMDBGLOG((LOCALDBG, "parsing instance %lu\n", *currentInstance));
				}
			} else {
				RMDBGLOG((LOCALDBG, "already parsing instance %lu\n", *currentInstance));
			}
			err = RM_OK;
		} else {
			err = RM_ERROR;
		}
		*index = i;
	} else {
		err = parse_audio_cmdline(argc, argv, index, &(options[*currentInstance]));
	}
	
	//RMDBGLOG((LOCALDBG, ">>>>>>>>>>>>Cmdline Speaker Configure = %0x\n", options[*currentInstance].OutputChannels));
	
	return err;
}

/** 
	@param dcc_info
	@param options      The audio options
	@param AudioCP      TRUE: set copy protection bit in SPDIF and HDMI IEC 60958-3 header (Bit 2, 'C')
	@param engine
*/
RMstatus set_audio_cp_bit(struct dcc_context *dcc_info, struct audio_cmdline *options, RMbool AudioCP, RMuint32 engine)
{
	struct AudioEngine_ChannelStatus_type cs;
	
	if (options->spdifChannelStatus.Mask & 0x00000004) {
		RMDBGLOG((LOCALDBG, "audioCP bit set by mask, ignore this call\n"));
		return RM_OK;
	}
	
	options->AudioCP = AudioCP;
	
	if (options->dh_info && options->dh_info->pDH && options->dh_check) {
		DHSetAudioCP(options->dh_info->pDH, options->AudioCP);
	}
	
	cs.Mask =  0x00000004;
	cs.Value = (options->AudioCP) ? 0x00000004 : 0x00000000;
	
	RMDBGLOG((LOCALDBG, "set_audio_cp_bit(mask 0x%08lx, value 0x%08lx)\n", cs.Mask, cs.Value));
	
	return set_audio_channel_status(dcc_info, cs, engine);
}


RMstatus set_audio_channel_status(struct dcc_context *dcc_info, struct AudioEngine_ChannelStatus_type cs, RMuint32 engine)
{
	RMDBGLOG((LOCALDBG, "set_audio_channel_status(mask 0x%08lx, value 0x%08lx)\n", cs.Mask, cs.Value));
	
	return RUASetProperty(dcc_info->pRUA, engine, RMAudioEnginePropertyID_ChannelStatus, &cs, sizeof(cs), 0);
}



/** 
	@param dcc_info
	@param options      The audio options
	@param NumChannel   Number of audio channels (2..8: force channel number, 0: detect from options->OutputChannels)
	@param LowFreqChannel_3  TRUE if Low Frequency Effect audio is on channel 3
	@param FrontCenterChannel_4  TRUE if Front Center audio is on channel 4
	@param FrontLeftRightCenterChannels_7_8  If LeftCenter/RightCenter channels exist, are they in the Front(TRUE) or Rear(FALSE)?
	See EIA/CEA-861-B Table 22 for possible channel assignments
*/

RMstatus apply_dvi_hdmi_audio_options(
	struct dcc_context *dcc_info, 
	struct audio_cmdline *options, 
	RMuint32 NumChannel, 
	RMbool LowFreqChannel_3, 
	RMbool FrontCenterChannel_4, 
	RMbool FrontLeftRightCenterChannels_7_8)
{
	RMstatus err;
	struct DH_AudioFormat AudioFormat;
	struct DH_AudioInfoFrame AudioInfoFrame;
	RMbool Supports_AI;
	struct AudioEngine_ChannelStatus_type cs;
	RMuint32 ChannelStat = 0, ChannelMask = 0;
	
	if (! options->dh_check) return RM_OK;  // nothing to do
	
	if (options->dh_info == NULL) {
		RMDBGPRINT((ENABLE, "HDMI Audio: no dh_info struct available!\n"));
		return RM_ERROR;  // no HDMI, nothing to do
	}
	
	if (options->dh_info->pDH == NULL) {
		RMDBGPRINT((ENABLE, "HDMI Audio: no HDMI handle available!\n"));
		return RM_ERROR;  // no HDMI, nothing to do
	}
	
	// copy current category code from audio engine
	err = RUAGetProperty(dcc_info->pRUA, 
		EMHWLIB_MODULE(AudioEngine, options->AudioEngineID), 
		RMAudioEnginePropertyID_ChannelStatus, 
		&cs, sizeof(cs));
	if (RMSUCCEEDED(err)) {
		RMDBGLOG((LOCALDBG, "Channel Status from SPDIF: 0x%04lX\n", cs.Value & 0xFFFF));
		if (((cs.Value & 0x04) ? TRUE : FALSE) != options->AudioCP) {
			//RMDBGLOG((LOCALDBG, "Mismatch of COPY PROTECTION bit in audio header! Please investigate!!!\n"));
			//DHSetAudioCP(pDH, (cs.Value & 0x04) ? TRUE : FALSE);
		}
		ChannelStat = cs.Value;
		ChannelMask = 0x0000FFF9;
	}
	
	err = convert_hdmi_audio_options(
		options->SampleRate, options->mclk, 
		options->OutputChannels, options->OutputLfe, 
		options->Spdif, options->Codec, 
		options->HDMIPassThrough, options->HDMIPassThroughI2SLines, 
		options->HBR_Enable, (options->HDMIPassThrough && (options->Codec != AudioDecoder_Codec_PCM)), options->HBR_HeaderID, 
		options->dh_info->pDBC, options->dh_info->nDBC, 
		NumChannel, LowFreqChannel_3, FrontCenterChannel_4, FrontLeftRightCenterChannels_7_8, 
		&AudioFormat, &AudioInfoFrame, &Supports_AI);
	if (RMFAILED(err)) return err;
	
	return apply_hdmi_audio(options->dh_info->pDH, 
		&AudioFormat, &AudioInfoFrame, Supports_AI, 
		options->AudioCP, ChannelStat, ChannelMask);
}

/* retrieve the current audio block settings, which are neeeded to set up the HDMI audio */
RMstatus query_current_hdmi_audio_options(struct audio_cmdline *audio_opt, RMbool *update)
{
	RMstatus err;
	RMuint32 SampleRate;
	enum MClkFactor mclk;
	enum AudioOutputChannels_type OutputChannels;
	RMbool OutputLfe;
	enum OutputSpdif_type Spdif;
	enum AudioDecoder_Codec_type Codec;
	RMbool HDMIPassThrough, HBR_Enable, HBR_Compressed;
	RMuint32 HDMIPassThroughI2SLines, HBR_HeaderID;
	
	*update = FALSE;
	
	if ((audio_opt == NULL) || (audio_opt->dh_info == NULL)) return RM_FATALINVALIDPOINTER;
	
	err = query_current_hdmi_audio_settings(
		audio_opt->dh_info->pDH, 
		EMHWLIB_MODULE(AudioEngine, audio_opt->AudioEngineID), 
		EMHWLIB_MODULE(AudioDecoder, audio_opt->AudioDecoderID), 
		&SampleRate, &mclk, 
		&OutputChannels, &OutputLfe, 
		&Spdif, &Codec, 
		&HDMIPassThrough, &HDMIPassThroughI2SLines, 
		&HBR_Enable, &HBR_Compressed, &HBR_HeaderID);
	if (RMFAILED(err)) return err;
	
	if (
		(SampleRate != audio_opt->SampleRate) || 
		(mclk != audio_opt->mclk) || 
		(OutputChannels != audio_opt->OutputChannels) || 
		(OutputLfe != audio_opt->OutputLfe) || 
		(Spdif != audio_opt->Spdif) || 
		(Codec != audio_opt->Codec) || 
		(HDMIPassThrough != audio_opt->HDMIPassThrough) || 
		(HDMIPassThrough && (
			(HDMIPassThroughI2SLines != audio_opt->HDMIPassThroughI2SLines) || 
			(HBR_Enable != audio_opt->HBR_Enable) || 
			(HBR_Enable && (
				(HBR_Compressed != audio_opt->HBR_Compressed) || 
				(HBR_HeaderID != audio_opt->HBR_HeaderID) 
			))
		))
	) {
		*update = TRUE;
		
		if (! manutest) {
			fprintf(stderr, "\n[HDMI audio] Detected changed settings:\n");
			if (audio_opt->SampleRate != SampleRate) fprintf(stderr, "\tSampleRate %lu --> %lu\n", audio_opt->SampleRate, SampleRate);
			if (audio_opt->mclk != mclk) fprintf(stderr, "\tMClkFactor %u --> %u\n", (audio_opt->mclk == MClkFactor_128Xfs) ? 128 : 256, (mclk == MClkFactor_128Xfs) ? 128 : 256);
			if (audio_opt->OutputChannels != OutputChannels) fprintf(stderr, "\tOutputChannels 0x%02X --> 0x%02X\n", audio_opt->OutputChannels, OutputChannels);
			if (audio_opt->OutputLfe != OutputLfe) fprintf(stderr, "\tOutputLfe %s --> %s\n", audio_opt->OutputLfe ? "TRUE" : "FALSE", OutputLfe ? "TRUE" : "FALSE");
			if (audio_opt->Spdif != Spdif) fprintf(stderr, "\tSpdif %u --> %u\n", audio_opt->Spdif, Spdif);
			if (audio_opt->Codec != Codec) fprintf(stderr, "\tCodec %u --> %u\n", audio_opt->Codec, Codec);
			if (audio_opt->HDMIPassThrough != HDMIPassThrough) fprintf(stderr, "\tHDMIPassThrough %s --> %s\n", audio_opt->HDMIPassThrough ? "TRUE" : "FALSE", HDMIPassThrough ? "TRUE" : "FALSE");
			if (HDMIPassThrough) {
				if (audio_opt->HDMIPassThroughI2SLines != HDMIPassThroughI2SLines) fprintf(stderr, "\tHDMIPassThroughI2SLines %lu --> %lu\n", audio_opt->HDMIPassThroughI2SLines, HDMIPassThroughI2SLines);
				if (audio_opt->HBR_Enable != HBR_Enable) fprintf(stderr, "\tHBR_Enable %s --> %s\n", audio_opt->HBR_Enable ? "TRUE" : "FALSE", HBR_Enable ? "TRUE" : "FALSE");
				if (HBR_Enable) {
					if (audio_opt->HBR_Compressed != HBR_Compressed) fprintf(stderr, "\tHBR_Compressed %s --> %s\n", aud