parse_audio_cmdline.c

SigmDesign SMP8634 media decode chip development SDK

			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if ( ! strcmp(argv[i], "-delay")) {
		if (argc > i+1) {
			options->CaptureDelay = strtol(argv[i+1], NULL, 10);
			i+=2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if ( ! strcmp(argv[i], "-spdif")) {
		if (argc > i+1) {
			if      (! strcmp(argv[i+1], "n"))   options->Spdif = OutputSpdif_Disable;
			else if (! strcmp(argv[i+1], "u"))   options->Spdif = OutputSpdif_Uncompressed;
			else if (! strcmp(argv[i+1], "c"))   options->Spdif = OutputSpdif_Compressed;
			else if (! strcmp(argv[i+1], "cnd")) options->Spdif = OutputSpdif_NoDecodeCompressed;
			else 
				err = RM_ERROR;
		}
		else
			err = RM_ERROR;

		if (err != RM_ERROR)
			err = RM_OK;
		i+=2;
	}
	else if ( ! strcmp(argv[i], "-hdmi_pass")) {
		options->HDMIPassThrough = TRUE;
		options->Spdif = OutputSpdif_Compressed;
		i++;
		err = RM_OK;
	}
	else if ( ! strcmp(argv[i], "-hdmi_lines")) {
		if (argc > i+1) {
			options->HDMIPassThroughI2SLines = strtol(argv[i+1], NULL, 10);
			i+=2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if ( ! strcmp(argv[i], "-hdmi_hbr")) {
		options->HBR_Enable = TRUE;
		options->HBR_Compressed = TRUE;
		i++;
		if ((argc > i) && (argv[i][0] != '-')) {
			options->HBR_HeaderID = strtol(argv[i], NULL, 10);
			i++;
		}
		err = RM_OK;
	}
	else if ( ! strcmp(argv[i], "-so")) {
		if (argc > i+1) {
			options->SerialOut = (strtol(argv[i+1], NULL, 10)) ? TRUE : FALSE;
			i+=2;
			err = RM_OK;
		}
		else
			err = RM_ERROR;
	}
	else if ( ! (strcmp(argv[i], "-dual"))) {
		if (argc > i+1) {
			if ( ! (strcmp(argv[i+1], "stereo"))) {
				options->OutputDualMode = DualMode_Stereo;
			} 
			else if ( ! (strcmp(argv[i+1], "left"))) {
				options->OutputDualMode = DualMode_LeftMono;
			} 
			else if ( ! (strcmp(argv[i+1], "right"))) {
				options->OutputDualMode = DualMode_RightMono;
			} 
			else if ( ! (strcmp(argv[i+1], "mix"))) {
				options->OutputDualMode = DualMode_MixMono;
			}
			else 
				err = RM_ERROR;
		}
		else
			err = RM_ERROR;

		if (err != RM_ERROR)
			err = RM_OK;
		i+=2;
	}
	else if ( ! (strcmp(argv[i], "-lsbfirst"))) {
		options->PcmCdaParams.MsbFirst = FALSE;
		i++;
		err = RM_OK;
	}
	else if ( ! (strcmp(argv[i], "-lfe"))) {
//		options->Ac3Params.OutputLfe = TRUE;
		options->OutputLfe = TRUE;
		i++;
		err = RM_OK;
	}
	else if ( ! (strcmp(argv[i], "-acmod2dual"))) {
		options->Ac3Params.Acmod2DualMode = TRUE;
		options->MpegParams.Acmod2DualMode = TRUE;
		options->AACParams.Acmod2DualMode = TRUE;

		RMDBGLOG((LOCALDBG, "!!!!!!!!!!!!! Set acmod2dual \n"));
		i++;
		err = RM_OK;
	}
	else if ( ! (strcmp(argv[i], "-downsample"))) {
		options->LpcmAobParams.DownSample = TRUE;	
		options->DownSample = TRUE;	
		i++;
		err = RM_OK;
	}
	else if ( ! strcmp(argv[i], "-unsigned")) {
		RMDBGLOG((LOCALDBG, ">>>>>>>>>>>>Unsigned PCM is set\n"));
		options->SignedPCM = FALSE;
		i++;
		err = RM_OK;
	}
	else if ( ! strcmp(argv[i], "-bassmode")) {
		RMDBGLOG((LOCALDBG, ">>>>>>>>>>>>BassMode is set\n"));
		if (argc > i+1) {
			options->BassMode = strtol(argv[i+1], NULL, 10);
		}
		else 
			err = RM_ERROR;
		
		i+=2;
		err = RM_OK;
	}
	else if (RMCompareAscii(argv[i], "-afifo")) {
		if (argc > i+1) {
			RMasciiToUInt32(argv[i+1], &(options->fifo_size));
			options->fifo_size *= 1024;
			i += 2;
			err = RM_OK;
		}
		else
			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;
	}
	
	*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)":""));


#if 0
		options[i].I2SAlign = 1;
		options[i].I2SSClkNormal = FALSE;
		options[i].I2SFrameNormal = FALSE;
		options[i].I2SLSBFirst = FALSE;
		options[i].I2S16Bit = FALSE;
		
		options[i].OutputChannelsExplicitAssign = FALSE;
		options[i].OutputChannels = Audio_Out_Ch_LR;
		options[i].OutputDualMode = DualMode_Stereo;
		options[i].Spdif 		= OutputSpdif_Uncompressed;
		options[i].HDMIPassThrough = FALSE;
		options[i].HDMIPassThroughI2SLines = 1;
		options[i].HBR_Enable = FALSE;  // TRUE if HDMI HighBitRate audio is used (for Dolby TrueHD, e.g.)
		options[i].HBR_Compressed = TRUE;
		options[i].HBR_HeaderID = 0x09;  // 4 bit HBR packet header ID
		options[i].OutputLfe 	= FALSE;
		options[i].SignedPCM 	= TRUE;
		options[i].BassMode	= 0;
		
		options[i].AACParams.InputFormat 		= 0;	// adif, no sync word
		//	options[i].AACParams.OutputLfe 		= FALSE;
		options[i].AACParams.OutputChannels	= Aac_LR;
		options[i].AACParams.OutputSurround20 = SurroundAsStream;
		options[i].AACParams.Acmod2DualMode = FALSE;

		options[i].Ac3Params.OutputSurround20 = SurroundAsStream;
		options[i].Ac3Params.OutputLfe = FALSE;
		options[i].Ac3Params.OutputChannels = Ac3_LR;
		options[i].Ac3Params.Acmod2DualMode = FALSE;
		options[i].Ac3Params.CompMode = CompMode_line_out;
		options[i].Ac3Params.DynScaleHi = 0x10000000;
		options[i].Ac3Params.DynScaleLo = 0x10000000;
		options[i].Ac3Params.PcmScale = 0x10000000;
		
		options[i].PcmCdaParams.ChannelAssign = PcmCda2_LR;
		options[i].PcmCdaParams.BitsPerSample = 24;
		options[i].PcmCdaParams.MsbFirst = TRUE;
		options[i].PcmCdaParams.OutputSurround20 = SurroundAsStream;
		
		options[i].LpcmVobParams.ChannelAssign = LpcmVob2_LR;
		options[i].LpcmVobParams.BitsPerSample = 24;
		options[i].LpcmVobParams.DownMix = FALSE;	// downmixing not yet implemented
		RMMemset(options[i].LpcmVobParams.CoefLR, 0, sizeof(options[i].LpcmVobParams.CoefLR));
		options[i].LpcmVobParams.OutputSurround20 = SurroundAsStream;
		
		
		options[i].LpcmAobParams.ChannelAssign = LpcmAob20_LR;
		options[i].LpcmAobParams.BitsPerSampleGroup1 = 24;
		options[i].LpcmAobParams.BitsPerSampleGroup2 = 24;
		options[i].LpcmAobParams.DownMix = FALSE;	// downmixing not yet implemented
		options[i].LpcmAobParams.Group2Shift = 0;
		options[i].LpcmAobParams.PhaseLR = 0;
		options[i].LpcmAobParams.DownSample = 0; //no downsampling
		RMMemset(options[i].LpcmAobParams.CoefLR, 0, sizeof(options[i].LpcmAobParams.CoefLR));
		options[i].LpcmAobParams.OutputSurround20 = SurroundAsStream;
		
		options[i].LpcmBDParams.ChannelAssign = PcmCda2_LR;
		options[i].LpcmBDParams.BitsPerSample = 16;
		options[i].LpcmBDParams.OutputSurround20 = SurroundAsStream;
		
		options[i].WmaParams.OutputChannels = Audio_Out_Ch_LR;
		options[i].WmaParams.ValidDownMixCoef = FALSE;
		RMMemset(options[i].WmaParams.DownMixCoef, 0, sizeof(options[i].WmaParams.DownMixCoef));
		options[i].WmaParams.DynamicRangeControl = Drc_high;
		options[i].WmaParams.OutputSurround20 = SurroundAsStream;
		
		
		options[i].MpegParams.OutputSurround20 = SurroundAsStream;
		options[i].MpegParams.Acmod2DualMode = FALSE;
		
		options[i].DtsParams.OutputChannels = Dts_LR;
		options[i].fifo_size = 0;
		options[i].xfer_count = 0;
		
		options[i].skip_first_n_bytes = 0;
		
		options[i].mclk_on_rclk = 0;
		
		options[i].transcode_ec3_to_ac3 = FALSE;
		
		options[i].AudioFreqFromStream = 0;  // force afreq