play_capture_main.c

1. 8623L平台

/*
 *
 * Copyright (c) 2001-2007 Sigma Designs, Inc. 
 * All Rights Reserved. Proprietary and Confidential.
 *
 */

/**
	@file   play_capture_main.c
	@brief  
	
	@author Christian Wolff Sean.Sekwon.Choi
*/

// to enable or disable the debug messages of this source file, put 1 or 0 below
#if 1
#define LOCALDBG ENABLE
#else
#define LOCALDBG DISABLE
#endif

#include "sample_os.h"
#define ALLOW_OS_CODE 1

#include "../rua/include/rua.h"
#include "../rua/include/rua_property.h"
#include "../dcc/include/dcc.h"
#include "../dcc/include/dcc_macros.h"
#include "../rmcore/include/rmstatustostring.h"
#include "../rmlibcw/include/rmlibcw.h"
#include "../emhwlib_hal/pll/include/pll_hal.h"
#include "command_ids.h"
#include "get_key.h"
#include "common.h"
#include "cmdline_options.h"


#include "play_capture_main.h"
#include "play_capture_video.h"
#include "play_capture_audio.h"
#include "play_capture_hdmi.h"
#include "play_capture_analog_video.h"
#include "play_capture_analog_audio.h"
#include "play_capture_board_specific.h"
#include "play_capture_SiI9031.h"
#include "play_capture_SAA7119.h"
#include "play_capture_TW9919.h"
#include "play_capture_AD9380.h"
#include "play_capture_WM8775.h"
#include "play_capture_MSP34x5.h"

// multi-thread lock
RMbool capsam_i2c_lock = FALSE;

struct capsam_main_instance {
	// Access
	struct dcc_context *dcc_info;
	enum capsam_access_type access_type;

	enum capsam_chip chip;
	enum capsam_input input;
	RMuint32 input_number;

	struct capsam_video_instance *pVideo;
	struct capsam_audio_instance *pAudio;
	struct capsam_hdmi_instance *pHDMI;  // handle to access HDMI chips
	struct capsam_analog_video_instance *pAnalogVideo; // handle to access Analog Video chips
	struct capsam_analog_audio_instance *pAnalogAudio; // handle to access Analog Audio chips
	
	capsam_main_callback_func callback_func;
	void *callback_context;
	
	// State
	struct capsam_update Update;
	enum EMhwlibTVStandard TVStandard;

	struct capture_cmdline *capture_opt;
	//struct local_cmdline *local_opt;
	struct audio_cmdline *audio_opt; 
	struct display_cmdline *disp_opt;

	RMbool is_format_detected;

	//struct capsam_chip_handle video_chip_handle[MAX_NUMBER_OF_VIDEO_CHIPS];
	//struct capsam_chip_handle audio_chip_handle[MAX_NUMBER_OF_AUDIO_CHIPS];
	
	struct capsam_SiI9031_instance *pSiI9031;
	struct capsam_AD9380_instance *pAD9380;
	struct capsam_TW9919_instance *pTW9919;
	struct capsam_AD9883_instance *pAD9883;
	struct capsam_SAA7119_instance *pSAA7119;
	struct capsam_WM8775_instance *pWM8775;
	struct capsam_MSP34x5_instance *pMSP34x5;
};

/* create the main instace */
RMstatus capsam_main_open(
	struct dcc_context *dcc_info, 
	struct capsam_main_instance **ppCapture,
	struct display_cmdline *disp_opt,
	struct capture_cmdline *capture_opt,
	struct audio_cmdline *audio_opt)
{
	struct capsam_main_instance *pCapture;
	
	// TODO STC
	//RMuint32 TimerNumber = 1;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	
	// Sanity checks
	if (ppCapture == NULL) return RM_FATALINVALIDPOINTER;
	*ppCapture = NULL;
	if (dcc_info == NULL) return RM_FATALINVALIDPOINTER;
	
	// Allocate and clear local instance
	pCapture = (struct capsam_main_instance *)RMMalloc(sizeof(struct capsam_main_instance));
	if (pCapture == NULL) {
		fprintf(stderr, "FATAL! Not enough memory for struct capsam_main_instance!\n");
		return RM_FATALOUTOFMEMORY;
	}
	RMMemset(pCapture, 0, sizeof(struct capsam_main_instance));
	*ppCapture = pCapture;
	
	// Set default and non-zero startup values
	pCapture->dcc_info = dcc_info;
	pCapture->access_type = capsam_access_type_none;
	
	pCapture->chip = capsam_chip_none;
	pCapture->input = capsam_input_none;
	pCapture->input_number = 0;
	
	pCapture->Update.APIVersion = 1;
	pCapture->disp_opt = disp_opt;
	pCapture->capture_opt = capture_opt;
	pCapture->audio_opt = audio_opt;
	pCapture->is_format_detected = FALSE;

	pCapture->pSiI9031 = NULL;
	pCapture->pAD9380  = NULL;
	pCapture->pTW9919 = NULL;
	pCapture->pAD9883 = NULL;
	pCapture->pSAA7119 = NULL;
	pCapture->pWM8775 = NULL;
	pCapture->pMSP34x5 = NULL;

	return RM_OK;
}

/* destroy the main instance, close open chips */
RMstatus capsam_main_close(
	struct capsam_main_instance *pCapture)
{
	RMstatus err = RM_OK;

	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	// Sanity checks
	if (pCapture == NULL) return RM_OK;  // already closed
	
	// Free all ressources
	if (pCapture->access_type != capsam_access_type_none) {
		err = capsam_main_close_input(pCapture);
	}
	
	if(pCapture->pSiI9031){
		err = capsam_SiI9031_close(pCapture->pSiI9031);
	}
	if(pCapture->pAD9380){
		err = capsam_AD9380_close(pCapture->pAD9380);
	}
	if(pCapture->pTW9919){
		err = capsam_TW9919_close(pCapture->pTW9919);
	}
	if(pCapture->pAD9883){
		//err = capsam_AD9883_close(pCapture->pAD9883);
	}
	if(pCapture->pSAA7119){
		err = capsam_SAA7119_close(pCapture->pSAA7119);
	}
	if(pCapture->pWM8775){
		err = capsam_WM8775_close(pCapture->pWM8775);
	}
	if(pCapture->pMSP34x5){
		err = capsam_MSP34x5_close(pCapture->pMSP34x5);
	}



	RMFree(pCapture);
	
	return err;
}

RMstatus capsam_main_register_callback(
	struct capsam_main_instance *pCapture, 
	capsam_main_callback_func callback_func, 
	void *pContext)
{
	// Sanity checks
	if (pCapture == NULL) return RM_FATALINVALIDPOINTER;
	
	pCapture->callback_func = callback_func;
	pCapture->callback_context = pContext;
	
	return RM_OK;
}

RMstatus capsam_main_initialize_chips(struct capsam_main_instance *pCapture, 
				   struct capsam_chip_info* p_video_chip_info,
				   struct capsam_chip_info* p_audio_chip_info)
{

	RMstatus err = RM_OK;
	RMuint32 i = 0;
	RMuint32 out_I2CModuleID;
	struct EMhwlibI2CDeviceParameter *pout_I2CDevice;

	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	// create handles
	for(i=0; i<MAX_NUMBER_OF_VIDEO_CHIPS; i++){
		err = capsam_get_I2CInfo(p_video_chip_info[i].chip,
				      p_video_chip_info,
				      &out_I2CModuleID, 
				      &pout_I2CDevice);	

		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to get I2C info: %s\n", RMstatusToString(err));
		}

		switch(p_video_chip_info[i].chip ){
		case capsam_chip_none:
			err = RM_NOT_SUPPORTED;  // no "direct" hdmi input
			break;
		case capsam_chip_SiI9031:
			err = capsam_SiI9031_open(pCapture->dcc_info->pRUA, 
					       &(pCapture->pSiI9031), 
					       out_I2CModuleID, 
					       pout_I2CDevice);
			break;
		case capsam_chip_AD9380:
			//err = capsam_AD9380_open(pCapture->ddc_info->pRUA, &(pHDMI->pAD9380), I2CModuleID, pI2CDevice);
			break;
		case capsam_chip_ADV7402: 
			break;	
		case capsam_chip_SAA7119:
			//err = capsam_SAA7119_open(pCapture->ddc_info->pRUA, &(pAnalogVideo->pSAA7119), I2CModuleID, pI2CDevice, XtalClock, SampleRate);
			break;
		case capsam_chip_TW9919:
			//err =  capsam_TW9919_open(pCapture->ddc_info->pRUA, &(pAnalogVideo->pTW9919), I2CModuleID, pI2CDevice, XtalClock);
			break;
		case capsam_chip_AD9883:
			err = RM_NOTIMPLEMENTED;  // TODO
			break;
		default:
			err = RM_INVALID_PARAMETER;
			return err;
		}
	}

	for(i=0; i<MAX_NUMBER_OF_AUDIO_CHIPS; i++){
		switch(p_audio_chip_info[i].chip ){
		case capsam_chip_none:
			err = RM_NOT_SUPPORTED;  // no "direct" hdmi input
			break;
		case capsam_chip_WM8775:
			//err = capsam_WM8775_open(pCapture->ddc_info->pRUA, &((struct capsam_analog_audio_instance *)*ppAnalogAudio)->pWM8775, pAudioChip);
			break;
		case capsam_chip_MSP34x5: 
			//err = capsam_MSP34x5_open(pCapture->ddc_info->pRUA, &((struct capsam_analog_audio_instance *)*ppAnalogAudio)->pMSP34x5, pAudioChip);
			break;
		default:
			break;
		}
	}	
	return err;

}

RMstatus capsam_main_initialize_input(struct capsam_main_instance *pCapture, 
				   enum capsam_video_input video_input, 
				   struct capsam_video_input_map* p_video_input_map,
				   enum capsam_audio_input audio_input,
				   struct capsam_audio_input_map* p_audio_input_map)
{
	RMstatus err = RM_OK;
	enum capsam_chip video_chip, audio_chip;
	void* pChipHandle = NULL;

	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	video_chip = capsam_get_video_capture_chip(video_input,  p_video_input_map);	
	audio_chip = capsam_get_audio_capture_chip(audio_input,  p_audio_input_map);	
	
	if(video_input >= capsam_input_dvi){
		pCapture->access_type = capsam_access_type_hdmi;

		// HDMI module instantiation
		switch(video_chip){
		case capsam_chip_SiI9031:
			pChipHandle = pCapture->pSiI9031;
			break;
		case capsam_chip_AD9380: 
			pChipHandle = pCapture->pAD9380;
			break;
		default:
			pChipHandle = NULL;
			break;
		}
		
		err = capsam_hdmi_open(pCapture->dcc_info->pRUA, 
				    &(pCapture->pHDMI), 
				    video_chip, 
				    pChipHandle);

		// initalize the chip, select input
		err = capsam_hdmi_select_input(pCapture->pHDMI, 0);
		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);
		
		
		{
			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);
		}

		
	}else{
		pCapture->access_type = capsam_access_type_analog;
		
		// Analog module instantiation
		switch(video_chip){
		case capsam_chip_SiI9031:
			pChipHandle = NULL;
			break;
		case capsam_chip_AD9380: 
			pChipHandle = pCapture->pAD9380;
			break;
		case capsam_chip_AD9883:
			pChipHandle = pCapture->pAD9883;
			break;	
		case capsam_chip_ADV7402: 
			//pChipHandle = pCapture->pADV7402;
			break;	
		case capsam_chip_SAA7119: 
			pChipHandle = pCapture->pSAA7119;
			break;
		case capsam_chip_WM8775:
			pChipHandle = pCapture->pWM8775;
			break;
		case capsam_chip_MSP34x5:
			pChipHandle = pCapture->pMSP34x5;
			break;
		case capsam_chip_TW9919:
			pChipHandle = pCapture->pTW9919;
			break;
		default:
			pChipHandle = NULL;
			break;
		}
		/*	
		err = capsam_analog_video_open(pCapture->dcc_info->pRUA, 
					    &(pCapture->pAnalogVideo), 
					    video_chip,
					    pBoard->XtalClock,
					    pCapture->audio_opt->SampleRate);
		*/
	}

	/*
	 * 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);

	}

	return err;
}

RMstatus capsam_main_select_input(
	struct capsam_main_instance *pCapture, 
	enum capsam_access_type access_type,
	struct capsam_board_config *pBoard)
{
	RMstatus err = RM_OK;
#if 0
	struct capsam_access *pInput = NULL;
	struct capsam_access *pInput2 = NULL;
	struct capsam_access *pAudioChip;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	
	// Sanity checks
	if (pCapture == NULL) return RM_FATALINVALIDPOINTER;
	if (pBoard == NULL) return RM_FATALINVALIDPOINTER;
	
	if (pBoard->APIVersion < 1) return RM_ERROR;
	
	if (pCapture->access_type != capsam_access_type_none) {
		fprintf(stderr, "WARNING: previous capture input has not been closed!\n");
		err = capsam_main_close_input(pCapture);
	}

	/*
	 * External Capture Chip Initialization
	*/
	
	switch (access_type) {
	case capsam_access_type_hdmi:
		// create the HDMI instance (ignore 'input')
		pInput = &(pBoard->chip_hdmi_config);
		err = capsam_hdmi_open(pCapture->dcc_info->pRUA, &(pCapture->pHDMI), pInput->chip, pInput->I2CModuleID, &(pInput->I2CDevice));
		if (RMFAILED(err)){
			printf("capsam_hdmi_open error\n");
			return err;
		}

		// this is board specific setting - have to figure out how to handle for multiple board.
		if(pBoard->board == capsam_sigma844e1dtv){
			struct SystemBlock_GPIO_type gpio;
			gpio.Bit = GPIOId_Sys_15;
			gpio.Data = FALSE;  // select HDMI audio
			RUASetProperty(pCapture->dcc_info->pRUA, SystemBlock, RMSystemBlockPropertyID_GPIO, &gpio, sizeof(gpio), 0);		
		 }

		if(pBoard->board == capsam_sigmaDTV8634){

			struct SystemBlock_GPIO_type gpio;
			struct SystemBlock_GPIO_type gpio_16, gpio_17, gpio_18;
			
			// 0. power up AD9380