play_capture_vbidata.c

1. 8623L平台

		printf("\n");
	}
}

static RMstatus close_CCFifo(
	struct dcc_context *dcc_info, 
	struct local_cmdline *local_opt, 
	RMuint32 input)
{
	RMstatus err;
	
	if (local_opt->enable_i2c_cc || local_opt->enable_i2c_wss) {
		struct Input_VBIReadbackI2C_type rb;
		rb.I2CDevice = local_opt->i2c_video_dev;
		rb.I2CDelay = local_opt->i2c_video_delay;
		rb.Enable_CC = FALSE;
		rb.Enable_WSS = FALSE;
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_VBIReadbackI2C, &rb, sizeof(rb), 
			"Failed to set property VBIReadbackI2C");
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_Validate, NULL, 0, 
			"Failed to validate input");
	}
	if (local_opt->i2c_cc.Enable) {
		local_opt->i2c_cc.Enable = FALSE;
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_VBIReadbackI2CCC, &(local_opt->i2c_cc), sizeof(local_opt->i2c_cc), 
			"Failed to set property VBIReadbackI2CCC");
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_Validate, NULL, 0, 
			"Failed to validate input");
		local_opt->i2c_cc.Enable = TRUE;
	}
	
	if (local_opt->ccfifo_id_in) {
		RUASetPendingProperty(dcc_info->pRUA, 
			local_opt->ccfifo_id_in, 
			RMCCFifoPropertyID_Close, NULL, 0, 
			"Can not close ccfifo");
	}
	if (local_opt->ccfifo_id_out) {
		RUASetPendingProperty(dcc_info->pRUA, 
			local_opt->ccfifo_id_out, 
			RMCCFifoPropertyID_Close, NULL, 0, 
			"Can not close ccfifo");
	}
	
	if (local_opt->ccfifo_addr_in) {
		DCCFree(dcc_info->pDCC, local_opt->ccfifo_addr_in);
		local_opt->ccfifo_addr_in = 0;
	}
	if (local_opt->ccfifo_addr_out) {
		DCCFree(dcc_info->pDCC, local_opt->ccfifo_addr_out);
		local_opt->ccfifo_addr_out = 0;
	}
	if (local_opt->use_soft_cc_decoder) {
		RMFRTKClose(dcc_info->rtk);
		
		err = DCCCloseVideoSource(dcc_info->pCCOSDSource);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot close cc-osd source: %s\n", RMstatusToString(err)));
		}
		dcc_info->pCCOSDSource = NULL;
	}
	
	return RM_OK;
}

// Open CCFifo
static RMstatus open_CCFifo(
	struct dcc_context *dcc_info, 
	struct local_cmdline *local_opt, 
	RMuint32 input)
{
	RMstatus err;
	RMuint32 entry_count, fifo_size, stc_id;
	struct CCFifo_Open_type cc_open;
	entry_count = 80;
	
	// set up 1st CCFifo for receiving 
	local_opt->ccfifo_id_in = EMHWLIB_MODULE(CCFifo, input * 2 + 0);
	
	err = RUAExchangeProperty(dcc_info->pRUA, local_opt->ccfifo_id_in, 
		RMCCFifoPropertyID_DRAMSize, 
		&entry_count, sizeof(entry_count), 
		&fifo_size, sizeof(fifo_size));
	if (RMFAILED(err)) {
		fprintf(stderr, "CCfifo error %s\n", RMstatusToString(err));
		return err;
	}
	
	local_opt->ccfifo_addr_in = DCCMalloc(dcc_info->pDCC, 0, RUA_DRAM_UNCACHED, fifo_size);
	DCCSTCGetModuleId(dcc_info->pStcSource, &stc_id);
	cc_open.UncachedAddress = local_opt->ccfifo_addr_in;
	cc_open.EntryCount = entry_count;
	cc_open.UncachedSize = fifo_size;
	cc_open.STCModuleId = stc_id;
	
	err = RUASetProperty(dcc_info->pRUA, local_opt->ccfifo_id_in, 
		RMCCFifoPropertyID_Open, 
		&cc_open, sizeof(cc_open), 0);
	if (RMFAILED(err)) {
		fprintf(stderr, "Can not open ccfifo: %s\n", RMstatusToString(err));
		return err;
	}
	
	// set up 2nd CCFifo for sending (if needed)
	local_opt->ccfifo_id_out = EMHWLIB_MODULE(CCFifo, input * 2 + 1);
	
	err = RUAExchangeProperty(dcc_info->pRUA, local_opt->ccfifo_id_out, 
		RMCCFifoPropertyID_DRAMSize, 
		&entry_count, sizeof(entry_count), 
		&fifo_size, sizeof(fifo_size));
	if (RMFAILED(err)) {
		fprintf(stderr, "CCfifo error %s\n", RMstatusToString(err));
		return err;
	}
	
	local_opt->ccfifo_addr_out = DCCMalloc(dcc_info->pDCC, 0, RUA_DRAM_UNCACHED, fifo_size);
	DCCSTCGetModuleId(dcc_info->pStcSource, &stc_id);
	cc_open.UncachedAddress = local_opt->ccfifo_addr_out;
	cc_open.EntryCount = entry_count;
	cc_open.UncachedSize = fifo_size;
	cc_open.STCModuleId = stc_id;
	
	err = RUASetProperty(dcc_info->pRUA, local_opt->ccfifo_id_out, 
		RMCCFifoPropertyID_Open, 
		&cc_open, sizeof(cc_open), 0);
	if (RMFAILED(err)) {
		fprintf(stderr, "Can not open output ccfifo: %s\n", RMstatusToString(err));
		return err;
	}
	return RM_OK;
}

static RMstatus apply_CCFifo(
	struct dcc_context *dcc_info, 
	struct local_cmdline *local_opt, 
	RMuint32 input)
{
	RMstatus err;
	RMuint32 mixer_id;
	
	if (local_opt->ccfifo_print || local_opt->use_soft_cc_decoder) {
		// route CC data through app 
		local_opt->ccfifo_id_send = local_opt->ccfifo_id_out;
	} else {
		// direct CC passthrough from capture to mixer 
		local_opt->ccfifo_id_send = local_opt->ccfifo_id_in;
	}
	dcc_info->ccfifo_out_id = local_opt->ccfifo_id_send;
	
	switch (dcc_info->route) {
		case DCCRoute_Main:
			mixer_id = EMHWLIB_MODULE(DispMainMixer, 0);
			break;
		case DCCRoute_Secondary:
			mixer_id = EMHWLIB_MODULE(DispVCRMixer, 0);
			break;
		default:
			return RM_ERROR;
	}
	
	if (local_opt->use_soft_cc_decoder) {
		struct DCCOSDProfile osd_profile;
		Rtk86Handle rtk_handle;
		struct EMhwlibDisplayWindow window;
		struct rmscc_init scc_init;
		RMuint32 mixer, scaler, src_index;
		
		if ((dcc_info->disp_info->osd_scaler[0] != DispOSDScaler) && ((input_num == 0) || (dcc_info->disp_info->osd_scaler[1] != DispOSDScaler))) {
			scaler = DispOSDScaler;
		} else if ((dcc_info->disp_info->osd_scaler[0] != DispGFXMultiScaler) && ((input_num == 0) || (dcc_info->disp_info->osd_scaler[1] != DispGFXMultiScaler))) {
			scaler = DispGFXMultiScaler;
		} else {
			scaler = DispVCRMultiScaler;
		}
		
		// create a buffer to draw the closed caption on 
		osd_profile.ColorSpace = EMhwlibColorSpace_RGB_0_255;
		osd_profile.ColorMode = EMhwlibColorMode_TrueColor;
		osd_profile.SamplingMode = EMhwlibSamplingMode_444;
		osd_profile.ColorFormat = EMhwlibColorFormat_32BPP;
		osd_profile.PixelAspectRatio.X = 1;
		osd_profile.PixelAspectRatio.Y = 1;
		osd_profile.Width = 640;
		osd_profile.Height = 480;
		
		window.X = 2048;
		window.Y = 2048;
		window.Width = 4096;
		window.Height = 4096;
		
		window.XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToCenter;
		window.YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToCenter;
		window.XMode = EMhwlibDisplayWindowValueMode_Relative;
		window.YMode = EMhwlibDisplayWindowValueMode_Relative;
		window.WidthMode = EMhwlibDisplayWindowValueMode_Relative;
		window.HeightMode = EMhwlibDisplayWindowValueMode_Relative;
		
		err = DCCOpenOSDVideoSource(dcc_info->pDCC, &osd_profile, &(dcc_info->pCCOSDSource));
		if (RMFAILED(err)) {
			fprintf(stderr, "Cannot open OSD decoder: %s\n", RMstatusToString(err));
			return err;
		}
		
		err = DCCClearOSDVideoSource(dcc_info->pCCOSDSource);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot clear the surface source: %s\n", RMstatusToString(err)));
			return err;
		}
		
		while ((err = RUASetProperty(dcc_info->pRUA, scaler, RMGenericPropertyID_ScalerInputWindow, &(window), sizeof(window), 0)) == RM_PENDING);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot set scaler input window on OSD surface: %s\n", RMstatusToString(err)));
			return err;
		}
		
		err = DCCSetSurfaceSource(dcc_info->pDCC, scaler, dcc_info->pCCOSDSource);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot set the surface source: %s\n", RMstatusToString(err)));
			return err;
		}
		
		err = RUAExchangeProperty(dcc_info->pRUA, mixer_id, RMGenericPropertyID_MixerSourceIndex, &scaler, sizeof(scaler), &src_index, sizeof(src_index));
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot get scaler index\n"));
			return err;
		}
		mixer = EMHWLIB_TARGET_MODULE(mixer_id, 0, src_index);
		
		window.Width  = 8 * 4096 / 10;
		window.Height = 8 * 4096 / 10;
		
		// TODO align CC window with active_window
		while ((err = RUASetProperty(dcc_info->pRUA, mixer, RMGenericPropertyID_MixerSourceWindow, &(window), sizeof(window), 0)) == RM_PENDING);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot set scaler output window: %s\n", RMstatusToString(err)));
			return err;
		}
		
		err = DCCEnableVideoSource(dcc_info->pCCOSDSource, TRUE);
		if (RMFAILED(err)){
			RMDBGLOG((ENABLE, "Error enabling OSD buffer: %s\n", RMstatusToString(err)));
			return err;
		}
		
		rtk_handle.pOSDSource = dcc_info->pCCOSDSource;
		rtk_handle.pRUA = dcc_info->pRUA;
		
		scc_init.rtk = RMFRTKOpen(&rtk_handle);
		if(scc_init.rtk == NULL){
			RMDBGLOG((ENABLE, "Error opening rtk: %s\n", RMstatusToString(err)));
			return err;
		}
		
		scc_init.resize_callback = NULL;
		if (local_opt->use_soft_cc_decoder == 2) {
			struct CCFifo_AllowedTypes_type allowed_types;
			// this asks the video decoder to put only the eia708 closed caption
			// data into the fifo. Its default is to put only eia608 so we don't need
			// to handle this when use_soft_cc_decoder == 1
			allowed_types.Allow608 = FALSE;
			allowed_types.Allow708 = TRUE;
			err = RUASetProperty(dcc_info->pRUA, local_opt->ccfifo_id_in, RMCCFifoPropertyID_AllowedTypes, &(allowed_types), sizeof(allowed_types), 0);
			if (RMFAILED(err)) {
				RMDBGLOG((ENABLE, "Cannot set scaler input window on OSD surface %d\n", err));
				return err;
			}
			// make this instance of rmscc a eia708 decoder 
			scc_init.format = rmscc_eia_708;
		} else if (local_opt->use_soft_cc_decoder == 1) {
			// make this instance of rmscc a eia608 decoder 
			scc_init.format = rmscc_eia_608;
		}
		dcc_info->scc = RMSCCOpen(&scc_init);
		dcc_info->rtk = scc_init.rtk;
		if (dcc_info->scc == NULL) {
			local_opt->use_soft_cc_decoder = 0;
		}
	}
	
	if (input == 0) {
		RMuint32 ccfifo_id = 0;
		
		// clear previous fifo on the mixer 
		RUASetPendingProperty(dcc_info->pRUA, mixer_id, 
			RMGenericPropertyID_CCFifo, 
			&ccfifo_id, sizeof(ccfifo_id), 
			"Cannot clear CC_fifo");
		
		// set the fifo on the mixer 
		RUASetPendingProperty(dcc_info->pRUA, mixer_id, 
			RMGenericPropertyID_CCFifo, 
			&(local_opt->ccfifo_id_send), sizeof(local_opt->ccfifo_id_send), 
			"Cannot set CC_fifo");
		
		RUASetPendingProperty(dcc_info->pRUA, mixer_id, 
			RMGenericPropertyID_Validate, NULL, 0, 
			"Cannot validate mixer settings");
	}
	
	// set the fifo on the input 
	RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
		RMGenericPropertyID_CCFifo, 
		&(local_opt->ccfifo_id_in), sizeof(local_opt->ccfifo_id_in), 
		"Cannot set CC_fifo on input");
	RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
		RMGenericPropertyID_Validate, NULL, 0, 
		"Cannot validate mixer settings");
	
	if (local_opt->enable_i2c_cc || local_opt->enable_i2c_wss) {
		struct Input_VBIReadbackI2C_type rb;
		rb.I2CDevice = local_opt->i2c_video_dev;
		rb.I2CDelay = local_opt->i2c_video_delay;
		rb.Enable_CC = local_opt->enable_i2c_cc;
		rb.Enable_WSS = local_opt->enable_i2c_wss;
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_VBIReadbackI2C, &rb, sizeof(rb), 
			"Failed to set property VBIReadbackI2C");
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_Validate, NULL, 0, 
			"Failed to validate input");
	}
	if (local_opt->i2c_cc.Enable) {
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_VBIReadbackI2CCC, &(local_opt->i2c_cc), sizeof(local_opt->i2c_cc), 
			"Failed to set property VBIReadbackI2CCC");
		RUASetPendingProperty(dcc_info->pRUA, capture_opt->InputModuleID, 
			RMGenericPropertyID_Validate, NULL, 0, 
			"Failed to validate input");
	}
	
	return RM_OK;
}

*/