librmmonitoring.c

1. 8623L平台

					percentage = 100;
			}

			/* Graph the percentage extracted from the string */
			pixel.y = graph_osd_height - GRAPH_BOTTOM_MARGIN - percentage;
			pixel.x = graph_current_column;
			RMFRTKSetPixel(rtk, &pixel, graph_color_table[graph_color_index]);

			/* Set the text's color to the same color used to graph the percentage */
			prop.fgColor = graph_color_table[graph_color_index];

			/* Advance to the next available color in the color table, wrapping if necessary */
			graph_color_index++;
			if (graph_color_index >= GRAPH_COLORS_MAX)
				graph_color_index = 0;
		}
	}

	RMFRTKDrawString(rtk, text, &position, &prop,  &outputRect[(*line_number)++]);
}

RMstatus start_monitoring(RMuint32 scaler_index)
{
	struct DCCOSDProfile  osd_profile;
	enum EMhwlibMixerSourceState state = EMhwlibMixerSourceState_Slave;
	RMuint32 surfaceID, scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0), src_index;
	RMuint32 osd_mixer = EMHWLIB_MODULE(DispMainMixer, 0);
	RMuint32 mixer_src;
        RMstatus err;
	Rtk86Handle handle;

#if (EM86XX_CHIP == EM86XX_CHIPID_TANGO2)
	RMbool enable;
#endif

        /* Open /proc files */
        fstc = open(STC_FILENAME, O_RDONLY);
        fvideo_decoder = open(VD_FILENAME, O_RDONLY);
        faudio_decoder = open(AD_FILENAME, O_RDONLY);
        fdmapool0 = open(DMA0_FILENAME, O_RDONLY);
        fdmapool1 = open(DMA1_FILENAME, O_RDONLY);

        if ((fstc == -1) || (fvideo_decoder == -1) || (faudio_decoder == -1)) {
		RMDBGLOG((ENABLE, "Unable to open em8xxx /proc entry.\n"));
		RMDBGLOG((ENABLE, "Did you compile em8xxx with the appropriate flags (-DWITH_PROC=1 and -DWITH_MONITORING=1)? \n"));
                return RM_ERROR;
        }
                
        if ((fdmapool0 == -1) || (fdmapool1 == -1)) {
		RMDBGLOG((ENABLE, "Unable to open llad /proc entry.\n"));
		RMDBGLOG((ENABLE, "Did you compile llad with the appropriate flags (-DWITH_PROC=1 and -DWITH_MONITORING=1)?\n"));
                return RM_ERROR;
        }

        /* Initialize RUA and DCC. */
	err = RUACreateInstance(&pRUA, 0);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error creating RUA instance: error %d.\n", (int) err));
		return err;
	}
	
	err = DCCOpen(pRUA, &pDCC);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error opening DCC: error %d.\n", (int) err));
		goto exit;
	}

	err = DCCInitChainEx(pDCC, DCCInitMode_LeaveDisplay);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error initializing micro-code: error %d.\n", (int) err));
		goto exit;
	}

	osd_profile.Width = 640;
	osd_profile.Height = 480;
	osd_profile.ColorMode = EMhwlibColorMode_TrueColorWithKey;
	osd_profile.ColorFormat = EMhwlibColorFormat_32BPP;
	osd_profile.SamplingMode = EMhwlibSamplingMode_444;
	osd_profile.ColorSpace = EMhwlibColorSpace_RGB_0_255;

#if (EM86XX_CHIP == EM86XX_CHIPID_TANGO2)

        /* Set up the connector. */
	DCCSetStandard(pDCC, DCCRoute_Main, EMhwlibTVStandard_NTSC_M);
        DCCEnableVideoConnector(pDCC, DCCRoute_Main, DCCVideoConnector_SVIDEO, TRUE);

	DCCSetRouteDisplayAspectRatio(pDCC, DCCRoute_Main, 4, 3);

        /* Set up the OSD surface. */
	err = DCCGetScalerModuleID(pDCC, DCCRoute_Main, DCCSurface_OSD, scaler_index, &surfaceID);
	if (RMFAILED(err)) {
		printf("Cannot get a surface to display OSD source: error %d.\n", (int) err);
		goto exit;
	}

	err = RUAExchangeProperty(pRUA, osd_mixer, RMGenericPropertyID_MixerSourceIndex, &surfaceID, sizeof(surfaceID), &src_index, sizeof(src_index));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get DCCSurface_OSD's index\n"));
		goto exit;
	}

	mixer_src = EMHWLIB_TARGET_MODULE(osd_mixer, 0, src_index);
	state = EMhwlibMixerSourceState_Master;
	while((err =  RUASetProperty(pRUA, mixer_src, RMGenericPropertyID_MixerSourceState, &state, sizeof(state), 0))==RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set DCCSurface_OSD's state on mixer\n"));
		goto exit;
	}

	while ((err = RUASetProperty(pRUA, mixer_src, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot RMGenericPropertyID_Validate mixer\n"));
		goto exit;
	}

	enable = FALSE;
	err =  RUASetProperty(pRUA, surfaceID, RMGenericPropertyID_Enable, &enable, sizeof(enable), 0);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot enable DCCSurface_OSD\n"));
		goto exit;
	}

     	err = DCCOpenOSDVideoSource(pDCC, &osd_profile, &pOSDSource);
	if (RMFAILED(err)) {
		printf("Cannot open the OSD surface source: error %d.\n", (int) err);
		goto exit;
	}

	/* clear the surface first */
	err = DCCClearOSDVideoSource(pOSDSource);
	if (RMFAILED(err)) {
		printf("Cannot clear the OSD surface: error %d.\n", (int) err);
		goto exit;
	}

	err = DCCSetSurfaceSource(pDCC, surfaceID, pOSDSource);
	if (RMFAILED(err)) {
		printf("Cannot set the OSD surface source: error %d.\n", (int) err);
		goto exit;
	}

	while ((err = RUASetProperty(pRUA, surfaceID, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot validate DCCSurface_OSD's input window: %s\n", RMstatusToString(err)));
		goto exit;
	}

	enable = TRUE;
	err =  RUASetProperty(pRUA, surfaceID, RMGenericPropertyID_Enable, &enable, sizeof(enable), 0);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot enable DCCSurface_OSD\n"));
		goto exit;
	}
#else
     	err = DCCOpenOSDVideoSource(pDCC, &osd_profile, &pOSDSource);
	if (RMFAILED(err)) {
		printf("Cannot open the OSD surface source: error %d.\n", (int) err);
		goto exit;
	}

	err = DCCGetScalerModuleID(pDCC, DCCRoute_Main, DCCSurface_OSD, scaler_index, &surfaceID);
	if (RMFAILED(err)) {
		printf("Cannot get a surface to display OSD source: error %d.\n", (int) err);
		goto exit;
	}
        
	err = DCCClearOSDVideoSource(pOSDSource);
	if (RMFAILED(err)) {
		printf("Cannot clear the OSD surface: error %d.\n", (int) err);
		goto exit;
	}

	err = DCCSetSurfaceSource(pDCC, surfaceID, pOSDSource);
	if (RMFAILED(err)) {
		printf("Cannot set the OSD surface source: error %d.\n", (int) err);
		goto exit;
	}

	DCCSetStandard(pDCC, DCCRoute_Main, EMhwlibTVStandard_NTSC_M);
	DCCSetRouteDisplayAspectRatio(pDCC, DCCRoute_Main, 4, 3);
	DCCEnableVideoSource(pOSDSource, TRUE);
        DCCEnableVideoConnector(pDCC, DCCRoute_Main, DCCVideoConnector_SVIDEO, TRUE);
#endif


        /* Set the GFX scaler source state on mixer. */
	scaler = EMHWLIB_MODULE(DispGFXMultiScaler, 0);

	err = DCCSetSurfaceSource(pDCC, scaler, NULL);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot unset gfx scaler's surface: error %d.\n", (int) err));
		goto exit;
	}

	err = RUAExchangeProperty(pRUA, osd_mixer, RMGenericPropertyID_MixerSourceIndex, &scaler, sizeof(scaler), &src_index, sizeof(src_index));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get scaler index: error %d.\n", (int) err));
		goto exit;
	}

	mixer_src = EMHWLIB_TARGET_MODULE(osd_mixer, 0, src_index);
	state = EMhwlibMixerSourceState_Slave;

	while ((err =  RUASetProperty(pRUA, mixer_src, RMGenericPropertyID_MixerSourceState, &state, sizeof(state), 0)) == RM_PENDING);
       	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set scaler's state on mixer: error %d.\n", (int) err));
		goto exit;
	}

	while ((err = RUASetProperty(pRUA, osd_mixer, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot validate mixer: error %d.\n", (int) err));
		goto exit;
	}

        /* Open RTK and load font. */
	handle.pOSDSource = pOSDSource;
	handle.pRUA = pRUA;
	rtk = RMFRTKOpen(&handle);
        
	RMFRTKLoadFontFile(rtk, RMNONASCII(FONT_FILE));
     
        RMFRTKClearScreen(rtk);

	/* Initialize the graph by drawing the top and bottom boundaries */
	graph_init(osd_profile.Width, osd_profile.Height);
        
        return RM_OK;

 exit:
	stop_monitoring();
	return err;
	
}

RMstatus stop_monitoring(void)
{
        RMstatus err;
	struct RUAEvent evt;
	RMbool empty_queue = FALSE;
        
       	/* Wait for all commands to be finished. */
	evt.ModuleID = EMHWLIB_MODULE(GFXEngine,0);
	evt.Mask = RUAEVENT_COMMANDCOMPLETION;
	while (!empty_queue) {
		RUAGetProperty(pRUA, EMHWLIB_MODULE(GFXEngine,0), RMGFXEnginePropertyID_CommandQueueEmpty, &empty_queue, sizeof(empty_queue));
		/* Avoid continuous polling. */
		if (!empty_queue) 
			while (RUAWaitForMultipleEvents(pRUA, &evt, 1, WAIT_TIMEOUT_US, NULL) != RM_OK)
				RMDBGLOG((ENABLE, "Waiting for a command to finish.\n"));
	}
        
        close(fvideo_decoder);
        close(faudio_decoder);
        close(fstc);
        close(fdmapool0);
        close(fdmapool1);

        if (rtk != NULL) {
        	err = RMFRTKClose(rtk);
        	if (RMFAILED(err)) {
        		RMDBGLOG((ENABLE, "Cannot close rtk: error %d.\n", err));
        		return err;
	        }
        }

        if (pOSDSource != NULL) {
        	err = DCCCloseVideoSource(pOSDSource);
        	if (RMFAILED(err)) {
        		RMDBGLOG((ENABLE, "Cannot close OSD source: error %d.\n", err));
        		return err;
	        }
        }
		
        if (pDCC != NULL) {
        	err = DCCClose(pDCC);
        	if (RMFAILED(err)) {
        		RMDBGLOG((ENABLE, "Cannot close DCC: error %d.\n", err));
        		return err;
	        }
        }

        if (pRUA != NULL) {
        	err = RUADestroyInstance(pRUA);
        	if (RMFAILED(err)) {
        		RMDBGLOG((ENABLE, "Cannot destroy RUA instance: error %d.\n", err));
        		return err;
	        }
        }

        return RM_OK;
}