play_capture_main.c

1. 8623L平台

			gpio.Bit = GPIOId_Eth_34;
			gpio.Data = TRUE;  // power up 
			RUASetProperty(pCapture->dcc_info->pRUA, SystemBlock, RMSystemBlockPropertyID_GPIO, &gpio, sizeof(gpio), 0);	
			
			// 1. audio input MUX setting
			gpio.Bit = GPIOId_Eth_23;
			gpio.Data = FALSE;  // route HDMI audio to I2S input
			RUASetProperty(pCapture->dcc_info->pRUA, SystemBlock, RMSystemBlockPropertyID_GPIO, &gpio, sizeof(gpio), 0);	
	
			// 2. HDMI input MUX setting
			gpio_16.Bit = GPIOId_Eth_18;
			gpio_16.Data = FALSE;  // route analog audio to I2S input
			
			gpio_17.Bit = GPIOId_Eth_19;
			gpio_17.Data = FALSE;  // route analog audio to I2S input
			
			gpio_18.Bit = GPIOId_Eth_20;
			gpio_18.Data = FALSE;  // route analog audio to I2S input

			switch(pBoard->chip_hdmi_config.input_number ){
			case 0:
				gpio_16.Data = TRUE;  // route analog audio to I2S input	
				break;
			case 1:
				gpio_17.Data = TRUE;  // route analog audio to I2S input		
				break;
			case 2:
				gpio_18.Data = TRUE;  // route analog audio to I2S input
				break;
			default:
				break;
			}

			RUASetProperty(pCapture->dcc_info->pRUA, 
				       SystemBlock, 
				       RMSystemBlockPropertyID_GPIO, 
				       &gpio_16, 
				       sizeof(gpio_16), 
				       0);
			
			RUASetProperty(pCapture->dcc_info->pRUA, 
				       SystemBlock, 
				       RMSystemBlockPropertyID_GPIO, 
				       &gpio_17, 
				       sizeof(gpio_17), 
				       0);
			
			RUASetProperty(pCapture->dcc_info->pRUA, 
				       SystemBlock, 
				       RMSystemBlockPropertyID_GPIO, 
				       &gpio_18, 
				       sizeof(gpio_18), 
				       0);
			

			// choi hack for now - had better move to appropriate place later
			// analog video chip should be power on to feed MCLK
			//
			pInput2 = &(pBoard->chip_analog_video_config);
			err = capsam_analog_video_open(pCapture->dcc_info->pRUA, 
						    &(pCapture->pAnalogVideo), 
						    pInput2->chip, 
						    pInput2->I2CModuleID, 
						    &(pInput2->I2CDevice),
						    pBoard->XtalClock,
						    pCapture->audio_opt->SampleRate
						    );
			if (RMFAILED(err)) return err;
			
			// choi - hack for now
			err = capsam_analog_video_select_input(pCapture->pAnalogVideo, pInput2);	

			// tristate analog video chip
			err = capsam_analog_video_tristate(pCapture->pAnalogVideo);
			
		}

		// initalize the chip, select input
		err = capsam_hdmi_select_input(pCapture->pHDMI, pInput->input_number);
		if (RMFAILED(err)){
			printf("capsam_hdmi_select_input error\n");
			return err;
		}

		// have to get initial mode
		err = capsam_hdmi_detect_mode(pCapture->pHDMI, 
					   NULL,
					   NULL,
					   &pCapture->Update.VideoUpdate,
					   &pCapture->Update.AudioUpdate);
		
		/*
		  RMstatus capsam_hdmi_detect_mode(
		  struct capsam_hdmi_instance *pHDMI, 
		  enum capsam_hdmi_mode *pHDMIMode, 
		  RMbool *pUpdateAVI,    // need to handle AVI Info Frame again
		  RMbool *pUpdateAudio,  // need to re-start audio
		  RMbool *pUpdateVideo)  // need to detect video mode
		*/
		
		{
			RMuint32 SampleRate = 0;
			err = capsam_hdmi_setup_audio(pCapture->pHDMI,
						   ((pCapture->audio_opt->mclk == MClkFactor_256Xfs) ? 256 : 128),
						   &SampleRate);
			printf("================HDMI SampleRate %ld ============== \n", SampleRate);
		}

		break;
	case capsam_access_type_analog:
		/*
		 * create Analog Video instance
		 */
		pInput = &(pBoard->chip_analog_video_config);
		err = capsam_analog_video_open(pCapture->dcc_info->pRUA, 
					    &(pCapture->pAnalogVideo), 
					    pInput->chip, 
					    pInput->I2CModuleID, 
					    &(pInput->I2CDevice),
					    pBoard->XtalClock,
					    pCapture->audio_opt->SampleRate
					    );
		if (RMFAILED(err)) return err;
		
		// initalize the chip, select input
		// this may cause change struct capsam_update. 
		// but actual change of EM8xxx input side will be deferred to capsam_main_loop 
		err = capsam_analog_video_select_input(pCapture->pAnalogVideo, pInput);
		
		/*
		 * create Analog Audio instance
		 */

		{
			struct SystemBlock_GPIO_type gpio;
			gpio.Bit = GPIOId_Sys_15;
			gpio.Data = TRUE;  // route analog audio to I2S input
			RUASetProperty(pCapture->dcc_info->pRUA, SystemBlock, RMSystemBlockPropertyID_GPIO, &gpio, sizeof(gpio), 0);		
		 }

		pAudioChip = &(pBoard->chip_analog_audio_config);
		err = capsam_analog_audio_open(pCapture->dcc_info->pRUA, 
					    &(pCapture->pAnalogAudio),
					    pAudioChip);
		err = capsam_analog_audio_select_input(pCapture->pAnalogAudio, pAudioChip);	
			
		pAudioChip = &(pBoard->chip_analog_audio_config2);
		err = capsam_analog_audio_open(pCapture->dcc_info->pRUA, 
					    &(pCapture->pAnalogAudio),
					    pAudioChip);
		err = capsam_analog_audio_select_input(pCapture->pAnalogAudio, pAudioChip);	
	
		break;
	default:
		err = RM_ERROR;
	}
	if (RMFAILED(err)) return err;
	
	/*
	 * Sigma Chip Capture Input Initialization & Start Capture
	*/	
	if(1){
		err = capsam_video_open(pCapture->dcc_info, 1, pCapture->disp_opt, pCapture->capture_opt, &pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to open video object: %s\n", RMstatusToString(err));
		}

		err = capsam_video_guess_format(pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to guess format: %s\n", RMstatusToString(err));
		}

		//err = capsam_video_start_capture(pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to start capture: %s\n", RMstatusToString(err));
		}

		err = capsam_video_start_passthrough(pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to start pass through: %s\n", RMstatusToString(err));
		}

	}


	// prepare audio passthrough
	if (pCapture->audio_opt->AudioIn) {
		struct capsam_audio_setup audio_setup;
		
		//pCapture->audio_opt->AudioIn = FALSE;  // handle audio capture in capsam_audio, not in apply_audio
		
		err = capsam_audio_open(pCapture->dcc_info, &pCapture->pAudio);
		
		RMMemset(&audio_setup, 0, sizeof(audio_setup));

		// TODO transfer info from audio_opt to audio_setup
		audio_setup.AudioInAlign = 1;
		audio_setup.STCTimerNumber = 1;
		audio_setup.audio_free_run = TRUE;
		audio_setup.CaptureType = 1;
		audio_setup.SampleRate = pCapture->audio_opt->SampleRate;

		err = capsam_audio_setup(pCapture->pAudio, &audio_setup, pCapture->audio_opt);

		err = capsam_audio_start_passthrough(pCapture->pAudio);

	}
	

	pCapture->access_type = access_type;
	
	pCapture->chip = pInput->chip;
	pCapture->input = pInput->input;
	pCapture->input_number = pInput->input_number;
#endif	
	return err;
}

/* close the selected input (tristates and closes the chip) */
RMstatus capsam_main_close_input(
	struct capsam_main_instance *pCapture)
{
	RMstatus err;
	
	// Sanity checks
	if (pCapture == NULL) return RM_FATALINVALIDPOINTER;

        //err = capsam_video_stop_capture(pCapture->pVideo);
	
	switch (pCapture->access_type) {
	case capsam_access_type_hdmi:
		// neutralize the chip
		err = capsam_hdmi_tristate(pCapture->pHDMI);
		if (RMFAILED(err)) return err;
		// destroy the HDMI instance
		err = capsam_hdmi_close(pCapture->pHDMI);
		if (RMFAILED(err)) return err;
		pCapture->pHDMI = NULL;
		break;
	case capsam_access_type_analog:
		// neutralize the chip
		err = capsam_analog_video_tristate(pCapture->pAnalogVideo);
		if (RMFAILED(err)) return err;
		// destroy the HDMI instance
		err = capsam_analog_video_close(pCapture->pAnalogVideo);
		if (RMFAILED(err)) return err;
		
		// neutralize the chip
		err = capsam_analog_audio_tristate(pCapture->pAnalogAudio);
		if (RMFAILED(err)) return err;
		// destroy the HDMI instance
		err = capsam_analog_audio_close(pCapture->pAnalogAudio);
		if (RMFAILED(err)) return err;
		
		pCapture->pHDMI = NULL;
		break;
	default:
		err = RM_ERROR;
	}
	if (RMFAILED(err)) return err;

	if(1){
		err = capsam_video_stop_capture(pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to stop capture: %s\n", RMstatusToString(err));
		}
		err = capsam_video_close(pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to close video object: %s\n", RMstatusToString(err));
		}
	}
		
	if (pCapture->pAudio != NULL) {

		err = capsam_audio_stop_passthrough(pCapture->pAudio);
		err = capsam_audio_close(pCapture->pAudio);


	}

	pCapture->access_type = capsam_access_type_none;
	
	pCapture->chip = capsam_chip_none;
	pCapture->input = capsam_input_none;
	pCapture->input_number = 0;
	
	RMMemset(&(pCapture->Update), 0, sizeof(struct capsam_update));
	pCapture->Update.APIVersion = 1;
	
	return RM_OK;
}

/* performs one cycle of the main loop checker thread */
RMstatus capsam_main_loop (
	struct capsam_main_instance *pCapture)
{
	RMstatus err = RM_OK;
	
	//RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	
	// Sanity checks
	if (pCapture == NULL) return RM_FATALINVALIDPOINTER;
	
	// check for changes on the chip or input
	switch (pCapture->access_type) {
	case capsam_access_type_hdmi:
		err = capsam_hdmi_check_int(pCapture->pHDMI);
		if (RMSUCCEEDED(err)) {
			err = capsam_hdmi_handle_int(pCapture->pHDMI, &(pCapture->Update));
		}
		break;
	case capsam_access_type_analog:
		err = capsam_analog_video_check_int(pCapture->pAnalogVideo);
		if (RMSUCCEEDED(err)) {
			err = capsam_analog_video_handle_int(pCapture->pAnalogVideo, &(pCapture->Update));
			//RMDBGLOG((LOCALDBG, "error %d\n",err));
		}		
		break;
	default:
		err = RM_ERROR;
		break;
	}
	
	if (RMFAILED(err)){
		//RMDBGLOG((LOCALDBG, "error occurred\n"));		
		return err;
	}
	
	if (pCapture->callback_func != NULL) {
		err = pCapture->callback_func(pCapture->callback_context, &(pCapture->Update));
	}
	
	// setup capture chip output with update
	switch (pCapture->access_type) {
	case capsam_access_type_hdmi:
		break;
	case capsam_access_type_analog:
		err = capsam_analog_video_setup_output(pCapture->pAnalogVideo,&(pCapture->Update));
		break;
	default:
		err = RM_ERROR;
	}
	
	// setup EMhwlib video-in input with update
	// setup EMhwlib audio-in input with update
	// handle updates
	

	if (pCapture->Update.TVStandardUpdate) {
		printf("pCapture->Update.TVStandard %d, %d\n", 
			pCapture->Update.TVStandardValid, 
			pCapture->Update.TVStandard);
		
		pCapture->Update.TVStandardUpdate = FALSE;
		if (pCapture->Update.TVStandardValid) {
			struct capsam_video_config video_config;
			capsam_video_get_config(pCapture->pVideo, &video_config);
			video_config.TVStandard = pCapture->Update.TVStandard;
			capsam_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.PictureAspectRatioUpdate) {
		printf("pCapture->Update.PictureAspectRatio %d, %lu:%lu\n", 
			pCapture->Update.PictureAspectRatioValid, 
			pCapture->Update.PictureAspectRatio.X, pCapture->Update.PictureAspectRatio.Y);
		
		pCapture->Update.PictureAspectRatioUpdate = FALSE;
		if (pCapture->Update.PictureAspectRatioValid) {
			struct capsam_video_config video_config;
			capsam_video_get_config(pCapture->pVideo, &video_config);
			video_config.PictureAspectRatio = pCapture->Update.PictureAspectRatio;
			capsam_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.PixelAspectRatioUpdate) {
		printf("pCapture->Update.PixelAspectRatio %d, %lu:%lu\n", 
			pCapture->Update.PixelAspectRatioValid, 
			pCapture->Update.PixelAspectRatio.X, pCapture->Update.PixelAspectRatio.Y);
		
		pCapture->Update.PixelAspectRatioUpdate = FALSE;
		if (pCapture->Update.PixelAspectRatioValid) {
			struct capsam_video_config video_config;
			capsam_video_get_config(pCapture->pVideo, &video_config);
			video_config.PixelAspectRatio = pCapture->Update.PixelAspectRatio;
			capsam_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.InputColorSpaceUpdate) {
		printf("pCapture->Update.InputColorSpace %d, %d\n", 
			pCapture->Update.InputColorSpaceValid, 
			pCapture->Update.InputColorSpace);
		
		pCapture->Update.InputColorSpaceUpdate = FALSE;
		if (pCapture->Update.InputColorSpaceValid) {
			struct capsam_video_config video_config;
			capsam_video_get_config(pCapture->pVideo, &video_config);
			video_config.InputColorSpace = pCapture->Update.InputColorSpace;
			capsam_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.InputColorFormatUpdate) {
		printf("pCapture->Update.InputColorFormat %d, %d\n", 
			pCapture->Update.InputColorFormatValid, 
			pCapture->Update.InputColorFormat);
		
		pCapture->Update.InputColorFormatUpdate = FALSE;
		if (pCapture->Update.InputColorFormatValid) {
			struct capsam_video_config video_config;
			capsam_video_get_config(pCapture->pVideo, &video_config);
			video_config.InputColorFormat = pCapture->Update.InputColorFormat;
			capsam_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.VideoRestart) {
		printf("pCapture->Update.VideoRestart\n");
		
		pCapture->Update.VideoRestart = FALSE;
		err = capsam_video_stop_passthrough(pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to start pass through: %s\n", RMstatusToString(err));
		}
		err = capsam_video_start_passthrough(pCapture->pVideo);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to start pass through: %s\n", RMstatusToString(err));
		}
	}
	
	if (pCapture->Update.AudioRestart) {
		pCapture->Update.AudioRestart = FALSE;
		err = capsam_audio_set_state(pCapture->pAudio, audio_state_request);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to request audio: %s\n", RMstatusToString(err));
		}
	}
	if (pCapture->Update.AudioOff) {
		pCapture->Update.AudioOff = FALSE;
		err = capsam_audio_set_state(pCapture->pAudio, audio_state_off);
	}
	// TODO etc.
	
	return RM_OK;
}

void* capsam_main_get_chip_handle(struct capsam_main_instance *pCapture, 
			       enum capsam_chip chip)
{
	switch(chip){
	case capsam_chip_SiI9031:
		return pCapture->pSiI9031;
		break;
	case capsam_chip_AD9380:
		return pCapture->pAD9380;
		break;
	case capsam_chip_AD9883:
		return pCapture->pAD9883;
		break;
	case capsam_chip_ADV7402:
		//return pCapture->pADV7402;
		break;
	case capsam_chip_SAA7119:
		return pCapture->pSAA7119;
		break;
	case capsam_chip_WM8775:
		return pCapture->pWM8775;
		break;
	case capsam_chip_MSP34x5:
		return pCapture->pMSP34x5;
		break;
	case capsam_chip_TW9919:
		return pCapture->pTW9919;
		break;
	default:
		return NULL;
		break;
	}
	return NULL;
}