rmcapture.c

1. 8623L平台

			RMDBGLOG((ENABLE, "================HDMI SampleRate %ld ============== \n", SampleRate));
		}
	} else {

		//
		// Analog Video/Audio Initializing
		//

		// Video input initializing
		pCapture->access_type = cap_access_type_analog;
		

		err = cap_analog_video_open(pCapture->pRUA, 
					    &(pCapture->pAnalogVideo), 
					    pVideoChipHandle);
	
		err = cap_analog_video_select_input(pCapture->pAnalogVideo,      
						    p_board_info->board,
						    video_input, 
						    video_input_num );
		if(0){
		// Audio input initializing
		err = cap_analog_audio_open(pCapture->pRUA, 
					    &(pCapture->pAnalogAudio), 
					    pAudioChipHandle);

		err = cap_analog_audio_select_input(pCapture->pAnalogAudio, 
						    p_board_info->board,
						    audio_input,
						    audio_input_num);	
		}
	}
	



	/*
	 * Sigma Chip Capture Input Initialization & Start Capture
	*/	
	if (1) {
		RMDBGLOG((LOCALDBG, "Opening cap_video\n"));
		err = cap_video_open(pCapture->pRUA, pCapture->pDCC, pCapture->cap_opt, &pCapture->pVideo);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to open video object: %s\n", RMstatusToString(err)));
		}
		
		err = cap_video_guess_format(pCapture->pVideo);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to guess video format: %s\n", RMstatusToString(err)));
		}
		
		err = cap_video_start_passthrough(pCapture->pVideo);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to start video pass through: %s\n", RMstatusToString(err)));
		}
	}
	
	// prepare audio passthrough
	if(0){
	if (pCapture->cap_opt->AudioIn) {
		struct cap_audio_setup audio_setup;
		
		RMDBGLOG((LOCALDBG, "Opening cap_audio\n"));
		err = cap_audio_open(pCapture->pRUA, pCapture->pDCC, pCapture->cap_opt, &pCapture->pAudio);
		
		RMMemset(&audio_setup, 0, sizeof(audio_setup));
		audio_setup.AudioEngineID        = pCapture->cap_opt->AudioEngineID;        // index of the emhwlib module AudioEngine
		audio_setup.AudioCaptureID       = pCapture->cap_opt->AudioEngineID;        // index of the emhwlib module AudioCapture
		audio_setup.AudioDecoderID       = pCapture->cap_opt->AudioDecoderID;       // index of the emhwlib module AudioDecoder
		audio_setup.VideoCaptureModuleID = pCapture->cap_opt->InputModuleID;        // emhwlib module ID of the video/graphic input
		audio_setup.STCTimerNumber       = pCapture->cap_opt->STCTimerNumber;       // STC timer to be used
		audio_setup.BitsPerSample        = pCapture->cap_opt->lpcm_24bit ? 24 : 16; // for PCM, 16 or 24 bits per sample
		audio_setup.SampleRate           = pCapture->cap_opt->SampleRate;           // nominal sample rate of the captured audio
		audio_setup.CaptureSource        = pCapture->cap_opt->CaptureSource;        // 0=I2S, 1=SPDIF 2=SPDIF from I2S pin
		audio_setup.CaptureBitstream     = pCapture->cap_opt->CaptureBitstream;     // selected bit stream number in the SPDIF header
		audio_setup.CaptureType          = pCapture->cap_opt->CaptureType;          // PCM or compressed ??? (unused)
		audio_setup.CaptureDelay         = pCapture->cap_opt->CaptureDelay;         // delay between the audio capture and playback, in units of 90 kHz
		audio_setup.ExternalClk          = pCapture->cap_opt->ExternalClk;          // FALSE: use internallly generated clock to play back captured audio, TRUE: use external clock from RClkIn0 pin
		audio_setup.ExternalClkFreq      = pCapture->cap_opt->ExternalClkFreq;      // If ExternalClk==TRUE, nominal frequency of the clock at RClkIn0 pin
		audio_setup.AudioInTandem        = pCapture->cap_opt->AudioInTandem;        // TODO: If TRUE, play back captured audio on both audio engines (not yet implemented)
		audio_setup.AudioInAlign         = pCapture->cap_opt->AudioInAlign;         // I2S bit alignment for the capture (0..31)
		audio_setup.AudioInLSBfirst      = pCapture->cap_opt->AudioInLSBfirst;      // I2S bit order (FALSE: MSB first, TRUE: LSB first)
		audio_setup.AudioInFrameInvert   = pCapture->cap_opt->AudioInFrameInvert;   // I2S sample order (FALSE: left sample on low LRClk, TRUE: left sample on high)
		audio_setup.AudioInSClkNegEdge   = pCapture->cap_opt->AudioInSClkNegEdge;   // I2S clock polarity (FALSE: bit sampled on rising edge, TRUE: bit sampled on falling edge)
		audio_setup.audio_free_run       = pCapture->cap_opt->audio_free_run;       // TRUE: don't syncronize audio playback to the PTS's of the capture, rely on the audio clock coherency instead
		err = cap_audio_setup(pCapture->pAudio, &audio_setup);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to set up audio capture: %s\n", RMstatusToString(err)));
		}
		
		err = cap_audio_start_passthrough(pCapture->pAudio);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to start audio pass through: %s\n", RMstatusToString(err)));
		}
	}
	}
	
	return RM_OK;
}

/* close the selected input (tristates and closes the chip) */
RMstatus rmcapture_close_input(
	struct rmcapture_instance *pCapture)
{
	RMstatus err;

	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	// Sanity checks
	if (pCapture == NULL) return RM_FATALINVALIDPOINTER;
	
	//err = cap_video_stop_capture(pCapture->pVideo);
	
	switch (pCapture->access_type) {
	case cap_access_type_hdmi:
		// neutralize the chip
		err = cap_hdmi_tristate(pCapture->pHDMI);
		if (RMFAILED(err)) return err;
		// destroy the HDMI instance
		err = cap_hdmi_close(pCapture->pHDMI);
		if (RMFAILED(err)) return err;
		pCapture->pHDMI = NULL;
		break;
	case cap_access_type_analog:
		// neutralize the chip
		err = cap_analog_video_tristate(pCapture->pAnalogVideo);
		if (RMFAILED(err)) return err;
		// destroy the HDMI instance
		err = cap_analog_video_close(pCapture->pAnalogVideo);
		if (RMFAILED(err)) return err;
		
		// neutralize the chip
		err = cap_analog_audio_tristate(pCapture->pAnalogAudio);
		if (RMFAILED(err)) return err;
		// destroy the HDMI instance
		err = cap_analog_audio_close(pCapture->pAnalogAudio);
		if (RMFAILED(err)) return err;
		
		pCapture->pAnalogVideo = NULL;
		pCapture->pAnalogAudio = NULL;
		break;
	default:
		err = RM_ERROR;
	}
	if (RMFAILED(err)) return err;

	if (1) {
		err = cap_video_stop_capture(pCapture->pVideo);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to stop capture: %s\n", RMstatusToString(err)));
		}
		err = cap_video_close(pCapture->pVideo);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to close video object: %s\n", RMstatusToString(err)));
		}
	}
		
	if (pCapture->pAudio != NULL) {
		err = cap_audio_stop_passthrough(pCapture->pAudio);
		err = cap_audio_close(pCapture->pAudio);
	}

	pCapture->access_type = cap_access_type_none;
	
//	pCapture->chip = cap_chip_none;
	pCapture->input = cap_video_input_none;
	pCapture->input_number = 0;
	
	RMMemset(&(pCapture->Update), 0, sizeof(struct cap_update));
	pCapture->Update.APIVersion = 1;
	
	return RM_OK;
}

/* performs one cycle of the main loop checker thread */
RMstatus rmcapture_loop (
	struct rmcapture_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 cap_access_type_hdmi:
		err = cap_hdmi_check_int(pCapture->pHDMI);
		if (RMSUCCEEDED(err)) {
			err = cap_hdmi_handle_int(pCapture->pHDMI, &(pCapture->Update));
		}
		break;
	case cap_access_type_analog:
		err = cap_analog_video_check_int(pCapture->pAnalogVideo);
		if (RMSUCCEEDED(err)) {
			err = cap_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 cap_access_type_hdmi:
		break;
	case cap_access_type_analog:
		err = cap_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) {
		RMDBGLOG((LOCALDBG, "pCapture->Update.TVStandard %d, %d\n", 
			pCapture->Update.TVStandardValid, 
			pCapture->Update.TVStandard));
		
		pCapture->Update.TVStandardUpdate = FALSE;
		if (pCapture->Update.TVStandardValid) {
			struct cap_video_config video_config;
			cap_video_get_config(pCapture->pVideo, &video_config);
			video_config.TVStandard = pCapture->Update.TVStandard;
			cap_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.PictureAspectRatioUpdate) {
		RMDBGLOG((LOCALDBG, "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 cap_video_config video_config;
			cap_video_get_config(pCapture->pVideo, &video_config);
			video_config.PictureAspectRatio = pCapture->Update.PictureAspectRatio;
			cap_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.PixelAspectRatioUpdate) {
		RMDBGLOG((LOCALDBG, "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 cap_video_config video_config;
			cap_video_get_config(pCapture->pVideo, &video_config);
			video_config.PixelAspectRatio = pCapture->Update.PixelAspectRatio;
			cap_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.InputColorSpaceUpdate) {
		RMDBGLOG((LOCALDBG, "pCapture->Update.InputColorSpace %d, %d\n", 
			pCapture->Update.InputColorSpaceValid, 
			pCapture->Update.InputColorSpace));
		
		pCapture->Update.InputColorSpaceUpdate = FALSE;
		if (pCapture->Update.InputColorSpaceValid) {
			struct cap_video_config video_config;
			cap_video_get_config(pCapture->pVideo, &video_config);
			video_config.InputColorSpace = pCapture->Update.InputColorSpace;
			cap_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.InputColorFormatUpdate) {
		RMDBGLOG((LOCALDBG, "pCapture->Update.InputColorFormat %d, %d\n", 
			pCapture->Update.InputColorFormatValid, 
			pCapture->Update.InputColorFormat));
		
		pCapture->Update.InputColorFormatUpdate = FALSE;
		if (pCapture->Update.InputColorFormatValid) {
			struct cap_video_config video_config;
			cap_video_get_config(pCapture->pVideo, &video_config);
			video_config.InputColorFormat = pCapture->Update.InputColorFormat;
			cap_video_set_config(pCapture->pVideo, &video_config);
			pCapture->Update.VideoRestart = TRUE;
		}
	}
	if (pCapture->Update.VideoRestart) {
		RMDBGLOG((LOCALDBG, "pCapture->Update.VideoRestart\n"));
		
		pCapture->Update.VideoRestart = FALSE;
		err = cap_video_stop_passthrough(pCapture->pVideo);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to start pass through: %s\n", RMstatusToString(err)));
		}
		err = cap_video_start_passthrough(pCapture->pVideo);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to start pass through: %s\n", RMstatusToString(err)));
		}
	}
	
	if (pCapture->Update.AudioRestart) {
		pCapture->Update.AudioRestart = FALSE;
		err = cap_audio_set_state(pCapture->pAudio, audio_state_request);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to request audio: %s\n", RMstatusToString(err)));
		}
	}
	if (pCapture->Update.AudioOff) {
		pCapture->Update.AudioOff = FALSE;
		err = cap_audio_set_state(pCapture->pAudio, audio_state_off);
	}
	// TODO etc.
	
	return RM_OK;
}

// Deliver specific chip handle across library
// if 'chip' is cap_chip_last, returns open chip with board's 'index' of any type
// else returns open chip number 'index' of the specified type
struct cap_chip_instance* rmcapture_get_chip_handle(struct rmcapture_instance *pCapture, enum cap_chip chip, RMuint32 index)
{
	RMuint32 i, found = 0;
	
	if (chip == cap_chip_last) {
		for (i = 0; i < MAX_NUMBER_OF_CHIPS; i++) {
			if (pCapture->chip_inst[i].index == index) {
				return &(pCapture->chip_inst[i]);
			}
		}
	} else {
		for (i = 0; i < MAX_NUMBER_OF_CHIPS; i++) {
			if (pCapture->chip_inst[i].chip == chip) {
				found++;
				if (found > index) {
					return &(pCapture->chip_inst[i]);
				}
			}
		}
	}
	return NULL;
}