gfx_stress.c

Sample code for use on smp 863x processor.

/*
 *
 * Copyright (c) Sigma Designs, Inc. 2002. All rights reserved.
 *
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/time.h>



#define ALLOW_OS_CODE 1
#include "common.h"

#include "../rmrtk/include/rmrtk.h"


#define KEYFLAGS (SET_KEY_DISPLAY | SET_KEY_PLAYBACK)
#define TIMEOUT_US 1000000

#define FONT_FILE "Vera.ttf"
RMuint32 gfx_dram_controller = 0;

/* 
 *  use the SEND_GFX_COMMAND if you don't want a continuos polling
 *  otherwise you can just write
 *  while( RUASetProperty(pRUA, moduleID, propertyID, pValue, ValueSize, 0) == RM_PENDING);
 *
 *  uncomment the following line if you want the application to wait for the completion of commands
 *  before going on (otherwise the command is queued, and the application only waits if the command
 *  queue is full)
 * 
 */


/* #define WAIT_FOR_COMMANDS */


#define SEND_GFX_COMMAND(pRUA, moduleID, propertyID, pValue, ValueSize)					\
{													\
	RMstatus err;											\
	RMuint32 n;											\
	n = 1005;											\
	do{												\
		err = RUASetProperty(pRUA, moduleID, propertyID, pValue, ValueSize, 0);			\
		if ((err == RM_PENDING)) {								\
 			struct RUAEvent evt;								\
			evt.ModuleID = moduleID;							\
			evt.Mask = RUAEVENT_COMMANDCOMPLETION;						\
			while (RUAWaitForMultipleEvents(pRUA, &evt, 1, TIMEOUT_US, NULL) != RM_OK)	\
				RMDBGLOG((ENABLE, "Waiting for a command to finish\n"));		\
                }											\
                        n--;										\
													\
	}while((n>0) && (err == RM_PENDING));								\
													\
	if (err != RM_OK) {										\
		RMDBGLOG((ENABLE, "Can't send command to command fifo\n" ));				\
		return err;										\
	}												\
													\
}







char *filename = (char *) NULL;


struct playback_cmdline play_opt;
struct display_cmdline disp_opt;
struct video_cmdline video_opt;

static struct dcc_context dcc_info = {0,};


static void show_usage(char *progname)
{
	show_display_options();
	show_video_options();
	
	fprintf(stderr, "------------------------------------------------------------\n");
	fprintf(stderr, "Minimum cmd line: %s <filename.jpg/filename.bmp>\n", progname);
	fprintf(stderr, "Image should be 256x256 or bigger and true color\n");
	fprintf(stderr, "------------------------------------------------------------\n");

	exit(1);
}

static void parse_cmdline(int argc, char *argv[])
{
	int i;

	i = 1;
	while ((argc > i)) {
		if ( ! strcmp(argv[i], "-gfxdram")) {
			if (argc > i+1) {
				gfx_dram_controller = strtol(argv[i+1], NULL, 10);
				i+=2;
			}
			else
				show_usage(argv[0]);
		}
	}

}



static RMstatus gfx_test( struct RUA *pRUA, RMuint32 osd_addr, struct DCCOSDProfile *osd_profile)
{
	RMstatus err;
	RMuint32 gfx;
	RMuint32 dram_buf = 0;
	struct GFXEngine_Open_type gfx_profile;
	struct timeval init, final;
	RMuint32 elapsed;
		RMuint32 total_bytes;
		RMuint32 transfer_count = 0;


	fprintf(stderr, "osd allocated at 0x%08lx\n", osd_addr); 

	
	/* init the gfx_engine */
	{
		RMuint32 chip_num;
		RMuint32 gfx_count; 
		
		struct GFXEngine_DRAMSize_in_type  dramSizeIn;
		struct GFXEngine_DRAMSize_out_type dramSizeOut;
		
		RMint32 i;
		
		chip_num = 0;
		
		dramSizeIn.CommandFIFOCount = 10;
		err = RUAExchangeProperty(pRUA, EMHWLIB_MODULE(GFXEngine,0), RMGFXEnginePropertyID_DRAMSize,
					  &dramSizeIn, sizeof(dramSizeIn), &dramSizeOut, sizeof(dramSizeOut));
		if (RMFAILED(err)) {
			fprintf(stderr, "Error getting dram size for gfx engine\n");
			return -1;
		}
		
		gfx_profile.CommandFIFOCount = dramSizeIn.CommandFIFOCount;
		gfx_profile.Priority = 1;
		gfx_profile.CachedSize = dramSizeOut.CachedSize;
		gfx_profile.UncachedSize = dramSizeOut.UncachedSize;
	
		if (gfx_profile.CachedSize > 0) {
			fprintf(stderr, "about to malloc cached, size %ld\n", gfx_profile.CachedSize);
			gfx_profile.CachedAddress = RUAMalloc(pRUA, gfx_dram_controller, RUA_DRAM_CACHED, gfx_profile.CachedSize);
		} else {
			gfx_profile.CachedAddress = 0;
		}
		
		gfx_profile.UncachedSize = dramSizeOut.UncachedSize;
		if (gfx_profile.UncachedSize > 0) {
			gfx_profile.UncachedAddress = RUAMalloc(pRUA, gfx_dram_controller, RUA_DRAM_UNCACHED, gfx_profile.UncachedSize);
		} else {
			gfx_profile.UncachedAddress = 0;
		}
		fprintf(stderr, "gfx engine task structure allocated at 0x%08lx\n", gfx_profile.UncachedAddress); 

		gfx = GFXEngine;
		
		err = RUAExchangeProperty(pRUA, EMHWLIB_MODULE(Enumerator,0),  RMEnumeratorPropertyID_CategoryIDToNumberOfInstances, 
					  &gfx, sizeof(gfx), &gfx_count, sizeof(gfx_count));
		if (RMFAILED(err)) {
			fprintf(stderr, "Error getting gfx engine count\n");
			return -1;
		}
			
		for (i=0 ; i<(RMint32) gfx_count ; i++) {
			gfx = EMHWLIB_MODULE(GFXEngine, i);
			err = RUASetProperty(pRUA, gfx, RMGFXEnginePropertyID_Open, &gfx_profile, sizeof(gfx_profile), 0);
			if (err == RM_OK) 
				break;
		}
		
		if (i==(RMint32)gfx_count) {
			fprintf(stderr, "Cannot open a gfx engine [0..%lu[\n", gfx_count);
			return -1;
		}
	}//*/
	

	
	/* setup NX  */
	{
		struct GFXEngine_Surface_type surface_param;
		struct GFXEngine_ColorFormat_type format_param;

		format_param.SurfaceID = GFX_SURFACE_ID_NX;
		format_param.MainMode = osd_profile->ColorMode; //wont care!
		format_param.SubMode = osd_profile->ColorFormat;
		format_param.SamplingMode = osd_profile->SamplingMode;
		format_param.ColorSpace = osd_profile->ColorSpace;
		SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_ColorFormat, &format_param, sizeof(format_param));
		
		surface_param.SurfaceID = GFX_SURFACE_ID_NX;
		surface_param.StartAddress = osd_addr;
		surface_param.TotalWidth = osd_profile->Width;
		surface_param.Tiled = FALSE;
		SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_Surface, &surface_param, sizeof(surface_param));


	}//*/
	
	/* just move (Y)  */
	{
		struct GFXEngine_Surface_type surface_param;
		struct GFXEngine_ColorFormat_type format_param;
		struct GFXEngine_MoveReplaceRectangle_type move_param;
		RMuint32 test_id = 0;
		RMuint32 test_transfer_count;
		
		format_param.SurfaceID = GFX_SURFACE_ID_Y;
		surface_param.SurfaceID = GFX_SURFACE_ID_Y;
		
		format_param.MainMode = osd_profile->ColorMode;
		format_param.SubMode = osd_profile->ColorFormat;
		format_param.SamplingMode = osd_profile->SamplingMode;
		format_param.ColorSpace = osd_profile->ColorSpace;

		
		surface_param.StartAddress = osd_addr;
		surface_param.TotalWidth = osd_profile->Width;
		surface_param.Tiled = FALSE;

		SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_ColorFormat, &format_param, sizeof(format_param));
		SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_Surface, &surface_param, sizeof(surface_param));

		move_param.SrcX = 0;
		move_param.SrcY = 0;
		move_param.Width = osd_profile->Width;//osd_profile->Width/2;
		move_param.Height = osd_profile->Height;//osd_profile->Height/2;
		move_param.DstX = 0;
		move_param.DstY = 0;//osd_profile->Height/2;
		move_param.AlphaX = 0;
		move_param.AlphaY = 0;
		move_param.Merge = FALSE;

		total_bytes = move_param.Width * move_param.Height;  /* read */
		total_bytes *= 2;  /* write */
		total_bytes *= 4; /* 32bpp */

		test_transfer_count = (512*1024*1024)/total_bytes;

		gettimeofday(&init, NULL);
		while(TRUE){
			if(transfer_count == test_transfer_count){
				gettimeofday(&final, NULL);
				elapsed = final.tv_sec - init.tv_sec;
				elapsed *= 1000000;
				elapsed += (RMint32)final.tv_usec - init.tv_usec;
				fprintf(stderr, "%ldkB/s (%ld ops per second) chunks are (%ld x %ld)\n", 
					(RMuint32) (((((RMuint64)transfer_count*total_bytes)/elapsed)*1000000)>>10), 
					(transfer_count*1000)/(elapsed/1000),
					move_param.Width,
					move_param.Height
					);
				move_param.Width -= (move_param.Width + 7)/8;
				move_param.Height -= (move_param.Height + 7)/8;
				if((!move_param.Width) ||
				   (!move_param.Height)){
					move_param.Width = osd_profile->Width;
					move_param.Height = osd_profile->Height;
				}

				total_bytes = move_param.Width * move_param.Height;  /* read */
				total_bytes *= 2;  /* write */
				total_bytes *= 4; /* 32bpp */
				/* calculate this here so that we don't need to make an extra multiplication on every command*/
				test_transfer_count = (512*1024*1024)/total_bytes;
				transfer_count=0;
				test_id++;
				gettimeofday(&init, NULL);
			}

			SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_MoveRectangle, &move_param, sizeof(move_param));
			transfer_count++;
		}

	}//*/
	/* just move (Y)  */
	{
		struct GFXEngine_Surface_type surface_param;
		struct GFXEngine_ColorFormat_type format_param;
		struct GFXEngine_MoveReplaceRectangle_type move_param;
		
		format_param.SurfaceID = GFX_SURFACE_ID_Y;
		surface_param.SurfaceID = GFX_SURFACE_ID_Y;
		
		format_param.MainMode = osd_profile->ColorMode;
		format_param.SubMode = osd_profile->ColorFormat;
		format_param.SamplingMode = osd_profile->SamplingMode;
		format_param.ColorSpace = osd_profile->ColorSpace;

		
		surface_param.StartAddress = osd_addr;
		surface_param.TotalWidth = osd_profile->Width;
		surface_param.Tiled = FALSE;

		SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_ColorFormat, &format_param, sizeof(format_param));
		SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_Surface, &surface_param, sizeof(surface_param));

		move_param.SrcX = 0;
		move_param.SrcY = 0;
		move_param.Width = osd_profile->Width;//osd_profile->Width/2;
		move_param.Height = osd_profile->Height;//osd_profile->Height/2;
		move_param.DstX = 0;
		move_param.DstY = 0;//osd_profile->Height/2;
		move_param.AlphaX = 0;
		move_param.AlphaY = 0;
		move_param.Merge = FALSE;

		total_bytes = move_param.Width * move_param.Height;  /* read */
		total_bytes *= 2;  /* write */
		total_bytes *= 4; /* 32bpp */

		
		while(TRUE){
			if(transfer_count ==500)/* move_param.SrcX >  (osd_profile->Width - move_param.Width)) */{
				gettimeofday(&final, NULL);
				elapsed = final.tv_sec - init.tv_sec;
				elapsed *= 1000000;
				elapsed += (RMint32)final.tv_usec - init.tv_usec;
				gettimeofday(&init, NULL);
				fprintf(stderr, "elapsed usecs %ld : %ldkB/s (transfer count %ld)\n", 
					elapsed,
					(RMuint32) (((((RMuint64)transfer_count*total_bytes)/elapsed)*1000000)>>10), transfer_count);
				transfer_count=0;
				move_param.SrcX  = 0;
			}

			SEND_GFX_COMMAND(pRUA, gfx, RMGFXEnginePropertyID_MoveRectangle, &move_param, sizeof(move_param));
/* 			move_param.SrcX++; */
			transfer_count++;
		}

	}//*/

	
	/* wait for all commands to be finished */
	{
		struct RUAEvent evt;
		RMbool empty_queue = FALSE;
		evt.ModuleID = gfx;
		evt.Mask = RUAEVENT_COMMANDCOMPLETION;
		while(!empty_queue){
			RUAGetProperty(pRUA, gfx, RMGFXEnginePropertyID_CommandQueueEmpty, &empty_queue, sizeof(empty_queue));
			/* the following lines could be removed if you don't care about a continuous polling */
			if(!empty_queue) {
				while( RUAWaitForMultipleEvents(pRUA, &evt, 1, TIMEOUT_US, NULL)!=RM_OK){
					RMDBGLOG((ENABLE, "Waiting for a command to finish\n"));
				}
			}
		}
	}
	
	
	/* close the gfx accelerator */
 	{
 		RMuint32 close_profile = 0;

		
 		err = RUASetProperty(pRUA, gfx, RMGFXEnginePropertyID_Close, &close_profile, sizeof(close_profile), 0);
 		if (RMFAILED(err)) fprintf(stderr, "Cannot close de gfx accelerator\n");

		if(dram_buf != 0)
				RUAFree(pRUA, dram_buf);
		if(gfx_profile.CachedAddress)		
			RUAFree(pRUA, gfx_profile.CachedAddress);

		if(gfx_profile.UncachedAddress)		
			RUAFree(pRUA, gfx_profile.UncachedAddress);
 	}//*/



	dram_buf = 0;
	return 0;
}




int main(int argc, char *argv[])
{
	struct DCC *pDCC = NULL;
	struct RUA *pRUA = NULL;
	RMuint32 osd_addr;
	RMstatus err;
	struct DCCOSDProfile  osd_profile;
/* 	RMuint32 mixer = 0, scaler, src_index, mixer_src; */
	struct display_context disp_info;
	struct dh_context dh_info = {0,};



	

	init_display_options(&disp_opt);
	init_video_options(&video_opt);
	init_playback_options(&play_opt);
	disp_opt.dh_info = &dh_info;

	parse_cmdline(argc, argv);

	err = RUACreateInstance(&pRUA, play_opt.chip_num);
	if (RMFAILED(err)) {
		fprintf(stderr, "Error creating RUA instance! %d\n", err);
		return -1;
	}
	
	err = DCCOpen(pRUA, &pDCC);
	if (RMFAILED(err)) {
		fprintf(stderr, "Error Opening DCC! %d\n", err);
		return err;
	}

	dcc_info.pRUA = pRUA;
 	dcc_info.pDCC = pDCC;
	dcc_info.route = DCCRoute_Main;
	dcc_info.disp_info = &disp_info;


/* 	fprintf( stdout, "press any key\n\n\n"); */
	osd_profile.ColorSpace = EMhwlibColorSpace_RGB_0_255;
	osd_profile.ColorFormat = EMhwlibColorFormat_32BPP;
	osd_profile.ColorMode = EMhwlibColorMode_TrueColor;
	osd_profile.SamplingMode = EMhwlibSamplingMode_444;
	osd_profile.Width = 1024;
	osd_profile.Height = 1024;
	osd_profile.PixelAspectRatio.X = 1;
	osd_profile.PixelAspectRatio.Y = 1;


	osd_addr = RUAMalloc(pRUA, gfx_dram_controller, RUA_DRAM_UNCACHED, osd_profile.Width*osd_profile.Height*4);

	gfx_test(dcc_info.pRUA, osd_addr, &osd_profile);
	fprintf( stdout, "gfx test done, press any key to quit\n");
	RMGetKey();

	err = RUADestroyInstance(pRUA);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot destroy RUA instance %d\n", err);
		return -1;
	}

	



	return 0;
	

}