rmcapture.c

1. 8623L平台

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

/**
	@file   rmcapture.c
	@brief  Main API for rmcapture. This contains all function the application needs to call.
	
	@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 "common.h"

// main functions
#include "../include/rmcapture.h"

// multi-thread lock
RMbool cap_i2c_lock = FALSE;

#define MAX_NUMBER_OF_CHIPS 20

struct rmcapture_instance {
	// Access
	struct RUA *pRUA;
	struct DCC *pDCC;
	enum cap_access_type access_type;
	
	enum cap_video_input input;
	RMuint32 input_number;
	
	struct cap_video_instance *pVideo;  // handle to access video capture of 86xx chip through emhwlib
	struct cap_audio_instance *pAudio;  // handle to access audio capture of 86xx chip through emhwlib
	struct cap_hdmi_instance *pHDMI;    // handle to access external HDMI chips
	struct cap_analog_video_instance *pAnalogVideo; // handle to access external Analog Video chips
	struct cap_analog_audio_instance *pAnalogAudio; // handle to access external Analog Audio chips
	
	rmcapture_callback_func callback_func;
	void *callback_context;
	
	// State
	struct cap_update Update;
	enum EMhwlibTVStandard TVStandard;
	
	struct rmcapture_options *cap_opt;
//	struct display_cmdline *disp_opt;  // TODO instead of modifying output through disp_opt, return AFD and rame rate info to application
	
	RMbool is_format_detected;
	
	enum cap_board board;
	struct cap_chip_instance chip_inst[MAX_NUMBER_OF_CHIPS];
};

/* create the main instace */
RMstatus rmcapture_open(
	struct RUA *pRUA, 
	struct DCC *pDCC, 
	struct rmcapture_options *cap_opt, 
//	struct display_cmdline *disp_opt, 
	struct rmcapture_instance **ppCapture)
{
	struct rmcapture_instance *pCapture;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	
	// Sanity checks
	if (ppCapture == NULL) return RM_FATALINVALIDPOINTER;
	*ppCapture = NULL;
	if (pRUA == NULL) return RM_FATALINVALIDPOINTER;
	if (pDCC == NULL) return RM_FATALINVALIDPOINTER;
	
	// Allocate and clear local instance
	pCapture = (struct rmcapture_instance *)RMMalloc(sizeof(struct rmcapture_instance));
	if (pCapture == NULL) {
		RMDBGLOG((ENABLE, "FATAL! Not enough memory for struct rmcapture_instance!\n"));
		return RM_FATALOUTOFMEMORY;
	}
	RMMemset(pCapture, 0, sizeof(struct rmcapture_instance));
	*ppCapture = pCapture;
	
	// Set default and non-zero startup values
	pCapture->pRUA = pRUA;
	pCapture->pDCC = pDCC;
	pCapture->access_type = cap_access_type_none;
	
	pCapture->input = cap_video_input_none;
	pCapture->input_number = 0;
	
	pCapture->Update.APIVersion = 1;
//	pCapture->disp_opt = disp_opt;
	pCapture->cap_opt = cap_opt;
	pCapture->is_format_detected = FALSE;
	
	return RM_OK;
}

/* destroy the main instance, close open chips */
RMstatus rmcapture_close(
	struct rmcapture_instance *pCapture)
{
	RMstatus err = RM_OK;
	RMuint32 i;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	// Sanity checks
	if (pCapture == NULL) return RM_OK;  // already closed
	
	// Free all ressources
	if (pCapture->access_type != cap_access_type_none) {
		err = rmcapture_close_input(pCapture);
	}
	
	for (i = 0; i < MAX_NUMBER_OF_CHIPS; i++) {
		switch (pCapture->chip_inst[i].chip) {
		case cap_chip_SiI9031:
			err = cap_SiI9031_close(pCapture->chip_inst[i].instance.pSiI9031);
			break;
		case cap_chip_AD9380:
			err = cap_AD9380_close(pCapture->chip_inst[i].instance.pAD9380);
			break;
		case cap_chip_TW9919:
			err = cap_TW9919_close(pCapture->chip_inst[i].instance.pTW9919);
			break;
		case cap_chip_SAA7119:
			err = cap_SAA7119_close(pCapture->chip_inst[i].instance.pSAA7119);
			break;
		case cap_chip_WM8775:
			err = cap_WM8775_close(pCapture->chip_inst[i].instance.pWM8775);
			break;
		case cap_chip_MSP34x5:
			err = cap_MSP34x5_close(pCapture->chip_inst[i].instance.pMSP34x5);
			break;
		default:
			err = RM_OK;
			break;
		}
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Failed to close chip #%lu: %s\n", i, RMstatusToString(err)));
		}
	}
	
	RMFree(pCapture);
	
	return err;
}

RMstatus rmcapture_register_callback(
	struct rmcapture_instance *pCapture, 
	rmcapture_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 rmcapture_initialize_chips(
	struct rmcapture_instance *pCapture, 
	enum cap_board board)
{
	RMstatus err = RM_OK;
	RMuint32 i, chip_num = 0;
	struct cap_board_info *p_board_info;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));
	
	p_board_info = cap_get_board_info(board);
	if (p_board_info == NULL) {
		RMDBGLOG((ENABLE, "Board not found!\n"));
		return RM_ERROR;
	}
	if (p_board_info->board != board) {
		RMDBGLOG((ENABLE, "Board info has wrong signature!\n"));
	}
	
	// create handles
	i = 0;
	while (p_board_info->p_chip_info[i].chip != cap_chip_last) {
		switch (p_board_info->p_chip_info[i].chip ) {
		case cap_chip_none:
			err = RM_NOT_SUPPORTED;  // no "direct" hdmi input
			break;
		case cap_chip_SiI9031:
			err = cap_SiI9031_open(pCapture->pRUA, 
				&(pCapture->chip_inst[chip_num].instance.pSiI9031), 
				EMHWLIB_MODULE(I2C, p_board_info->p_chip_info[i].I2CModule), 
				&(p_board_info->p_chip_info[i].I2CDevice));
			break;
		case cap_chip_AD9380:
			err = cap_AD9380_open(pCapture->pRUA, 
					      &(pCapture->chip_inst[chip_num].instance.pAD9380), 
					      EMHWLIB_MODULE(I2C, p_board_info->p_chip_info[i].I2CModule), 
					      &(p_board_info->p_chip_info[i].I2CDevice));
			break;
		case cap_chip_ADV7402: 
			err = RM_NOTIMPLEMENTED;
			break;	
		case cap_chip_SAA7119:
			err = cap_SAA7119_open(pCapture->pRUA, 
					       &(pCapture->chip_inst[chip_num].instance.pSAA7119), 
					       EMHWLIB_MODULE(I2C, p_board_info->p_chip_info[i].I2CModule), 
					       &(p_board_info->p_chip_info[i].I2CDevice),
					       p_board_info->clock,
					       pCapture->cap_opt->SampleRate);
			break;
		case cap_chip_TW9919:
			err =  cap_TW9919_open(pCapture->pRUA, 
					       &(pCapture->chip_inst[chip_num].instance.pTW9919), 
					       EMHWLIB_MODULE(I2C, p_board_info->p_chip_info[i].I2CModule), 
					       &(p_board_info->p_chip_info[i].I2CDevice),
					       p_board_info->clock);
			break;
		case cap_chip_AD9883:
			err = cap_AD9883_open(pCapture->pRUA, 
					      &(pCapture->chip_inst[chip_num].instance.pAD9883), 
					      EMHWLIB_MODULE(I2C, p_board_info->p_chip_info[i].I2CModule), 
					      &(p_board_info->p_chip_info[i].I2CDevice));
			break;
		case cap_chip_WM8775:
			err = cap_WM8775_open(pCapture->pRUA, 
					      &(pCapture->chip_inst[chip_num].instance.pWM8775), 
					      EMHWLIB_MODULE(I2C, p_board_info->p_chip_info[i].I2CModule), 
					      &(p_board_info->p_chip_info[i].I2CDevice));
			break;
		case cap_chip_MSP34x5: 
			err = cap_MSP34x5_open(pCapture->pRUA, 
					       &(pCapture->chip_inst[chip_num].instance.pMSP34x5), 
					       EMHWLIB_MODULE(I2C, p_board_info->p_chip_info[i].I2CModule), 
					       &(p_board_info->p_chip_info[i].I2CDevice));
			

			break;
		default:
			err = RM_INVALID_PARAMETER;
		}
		if (RMSUCCEEDED(err)) {
			// Add opened chip to the chip list of this instance
			pCapture->chip_inst[chip_num].chip = p_board_info->p_chip_info[i].chip;
			pCapture->chip_inst[chip_num].index = i;
			chip_num++;
		}
		i++;
	}
	
	pCapture->board = board;
	
	return err;
}

RMstatus rmcapture_initialize_input(
	struct rmcapture_instance *pCapture, 
	enum cap_video_input video_input, RMuint32 video_input_num, 
	RMbool force_audio_input, 
	enum cap_audio_input audio_input, RMuint32 audio_input_num)
{
	RMstatus err = RM_OK;
	RMuint32 i;
	enum cap_chip video_chip, audio_chip;
	RMuint32 video_chip_index = 0, audio_map_index, audio_chip_index;
	struct cap_chip_instance *pVideoChipHandle = NULL;
	struct cap_chip_instance *pAudioChipHandle = NULL;
	struct cap_board_info *p_board_info;
	
	RMDBGLOG((FUNCNAME, "%s\n",__func__));
	
	p_board_info = cap_get_board_info(pCapture->board);
	if (p_board_info == NULL) {
		RMDBGLOG((ENABLE, "Board not found!\n"));
		return RM_ERROR;
	}

	// board specific setting - should be moved somewhere else
	cap_board_specific_setup(pCapture, pCapture->pRUA, p_board_info, video_input, video_input_num);
	
	// discover right 
	i = 0;
	err = RM_NOT_FOUND;
	while (p_board_info->p_video_input_map[i].input != cap_video_input_last) {
		if ((p_board_info->p_video_input_map[i].input == video_input) && (p_board_info->p_video_input_map[i].input_num == video_input_num)) {
			video_chip_index = p_board_info->p_video_input_map[i].index;
			audio_map_index = p_board_info->p_video_input_map[i].audio_map_index;
			video_chip = p_board_info->p_chip_info[video_chip_index].chip;
			err = RM_OK;
		}
		i++;
	}
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Specified video input not found!\n"));
		return err;
	}
	if (force_audio_input) {
		i = 0;
		err = RM_NOT_FOUND;
		while (p_board_info->p_audio_input_map[i].input != cap_audio_input_last) {
			if ((p_board_info->p_audio_input_map[i].input == audio_input) && (p_board_info->p_audio_input_map[i].input_num == audio_input_num)) {
				audio_chip_index = p_board_info->p_audio_input_map[i].index;
				err = RM_OK;
			}
			i++;
		}
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Specified audio input not found!\n"));
			return err;
		}
	} else {
		audio_chip_index = p_board_info->p_audio_input_map[audio_map_index].index;
	}
	audio_chip = p_board_info->p_chip_info[audio_chip_index].chip;
	
	pVideoChipHandle = rmcapture_get_chip_handle(pCapture, cap_chip_last, video_chip_index);
	
	if ((video_input == cap_video_input_dvi) || (video_input == cap_video_input_hdmi)) {

		//
		// HDMI input initializing
		//

		pCapture->access_type = cap_access_type_hdmi;
		
		// HDMI module instantiation
		err = cap_hdmi_open(pCapture->pRUA, 
			pVideoChipHandle, 
			&(pCapture->pHDMI));
		
		// initalize the chip, select input
		err = cap_hdmi_select_input(pCapture->pHDMI, video_input_num - 1);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "cap_hdmi_select_input error\n"));
			return err;
		}
		
		// have to get initial mode
		err = cap_hdmi_detect_mode(pCapture->pHDMI, 
			NULL, 
			NULL, 
			&pCapture->Update.VideoUpdate, 
			&pCapture->Update.AudioUpdate);
		
		{
			RMuint32 SampleRate = 0;
			err = cap_hdmi_setup_audio(pCapture->pHDMI, 
				((pCapture->cap_opt->mclk == MClkFactor_256Xfs) ? 256 : 128), 
				&SampleRate);