play_gfx.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>


#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 */


#ifdef WAIT_FOR_COMMANDS
#define SEND_GFX_COMMAND(pRUA, moduleID, propertyID, pValue, ValueSize)					\
{													\
	RMstatus err;											\
	RMuint32 n = 5;											\
													\
	struct RUAEvent evt;										\
	evt.ModuleID = moduleID;									\
	evt.Mask = RUAEVENT_COMMANDCOMPLETION;								\
	do{												\
		err = RUASetProperty(pRUA, moduleID, propertyID, pValue, ValueSize, 0);			\
		if(err == RM_PENDING){									\
			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;										\
	}												\
	while (RUAWaitForMultipleEvents(pRUA, &evt, 1, TIMEOUT_US, NULL) != RM_OK)			\
		RMDBGLOG((ENABLE, "Waiting for a command to finish\n"));				\
}													\

#else													

#define SEND_GFX_COMMAND(pRUA, moduleID, propertyID, pValue, ValueSize)					\
{													\
	RMstatus err;											\
	RMuint32 n;											\
	n = 5;												\
	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;										\
	}												\
													\
}

#endif /* WAIT_FOR_COMMANDS */






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;
	RMstatus err;

	if (argc < 2) 
		show_usage(argv[0]);
	
	i = 1;
	while ((argc > i)) {
		if (argv[i][0] != '-') {
			if (filename == NULL) {
				filename = argv[i];
				i++;
			}
			else
				show_usage(argv[0]);
		}
		else 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]);
		}

		else {
			err = parse_playback_cmdline(argc, argv, &i, &play_opt);
			if (err == RM_ERROR) 
				show_usage(argv[0]);
			if (err != RM_PENDING)
				continue;
			err = parse_display_cmdline(argc, argv, &i, &disp_opt);
			if (err == RM_ERROR) 
				show_usage(argv[0]);
			if (err != RM_PENDING)
				continue;
			err = parse_video_cmdline(argc, argv, &i, &video_opt);
			if (RMFAILED(err))
				show_usage(argv[0]);
		}
	}

	if (filename == NULL)
		show_usage(argv[0]);
}


static void gfx_waitkey(struct dcc_context *dcc_info, struct display_cmdline *disp_opt)
{
	RMascii key;
	fprintf(stderr, "press <enter> to continue\n");
	while (! RMGetKeyNoWait(&key)) {
		update_hdmi(dcc_info, disp_opt, NULL);
	}
}

static RMstatus gfx_test(struct dcc_context *dcc_info, struct display_cmdline *disp_opt, RMuint32 osd_addr, struct DCCOSDProfile *osd_profile)
{
	RMstatus err;
	RMuint32 gfx;
	RMuint32 dram_buf = 0;
	struct GFXEngine_Open_type gfx_profile;

	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(dcc_info->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(dcc_info->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(dcc_info->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(dcc_info->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(dcc_info->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 channels  */
	{
		struct GFXEngine_Surface_type surface_param;
		struct GFXEngine_ColorFormat_type format_param;

		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;

		/* on all  the examples, all channels read (and write, in the case of NX)
		 * from (to) the same surface: the displayed picture. We can set them up all 
		 * at once with the same parameters.
		 */

		surface_param.SurfaceID = GFX_SURFACE_ID_NX;
		format_param.SurfaceID = GFX_SURFACE_ID_NX;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_Surface, &surface_param, sizeof(surface_param));
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_ColorFormat, &format_param, sizeof(format_param));

		surface_param.SurfaceID = GFX_SURFACE_ID_X;
		format_param.SurfaceID = GFX_SURFACE_ID_X;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_Surface, &surface_param, sizeof(surface_param));
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_ColorFormat, &format_param, sizeof(format_param));

		surface_param.SurfaceID = GFX_SURFACE_ID_Y;
		format_param.SurfaceID = GFX_SURFACE_ID_Y;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_Surface, &surface_param, sizeof(surface_param));
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_ColorFormat, &format_param, sizeof(format_param));

		surface_param.SurfaceID = GFX_SURFACE_ID_Z;
		format_param.SurfaceID = GFX_SURFACE_ID_Z;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_Surface, &surface_param, sizeof(surface_param));
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_ColorFormat, &format_param, sizeof(format_param));

	}//*/
	
	
	gfx_waitkey(dcc_info, disp_opt);

	/* fill */
	{
		struct GFXEngine_FillRectangle_type fill_param;

		fill_param.X = (osd_profile->Width/5);
		fill_param.Y = (osd_profile->Height/5);
		fill_param.Width = osd_profile->Width/5;
		fill_param.Height = osd_profile->Height/5;
		fill_param.Color = 0xffffff00;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_FillRectangle, &fill_param, sizeof(fill_param));

	}//*/
	

	gfx_waitkey(dcc_info, disp_opt);

	/* just move (Y)  */
	{
		struct GFXEngine_MoveReplaceRectangle_type move_param;

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

		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_MoveRectangle, &move_param, sizeof(move_param));
	}//*/
	
	gfx_waitkey(dcc_info, disp_opt);

	/* move and scale  (Z) */
	{
		struct GFXEngine_MoveReplaceScaleRectangle_type move_param;
		move_param.SrcX = 0;
		move_param.SrcY = 0;
		move_param.SrcWidth = osd_profile->Width;
		move_param.SrcHeight = osd_profile->Height;
		move_param.DstX = 3*(osd_profile->Width/5);
		move_param.DstY = 3*(osd_profile->Height/5);
		move_param.DstWidth = osd_profile->Width/5;
		move_param.DstHeight = osd_profile->Height/5;
		move_param.AlphaX = 0;
		move_param.AlphaY = 0;
		move_param.Merge = FALSE;

		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_MoveAndScaleRectangle, &move_param, sizeof(move_param));
	}//*/
	
	gfx_waitkey(dcc_info, disp_opt);

	/* blend and scale  (Z) */
	{
		struct GFXEngine_BlendAndScaleRectangles_type blend_param;
		blend_param.Src1X = 0;
		blend_param.Src1Y = 0;
		blend_param.Src2X = 1*(osd_profile->Width/5);
		blend_param.Src2Y = 3*(osd_profile->Height/5);
		blend_param.SrcWidth = osd_profile->Width;
		blend_param.SrcHeight = osd_profile->Height;
		blend_param.DstX = 1*(osd_profile->Width/5);
		blend_param.DstY = 3*(osd_profile->Height/5);
		blend_param.DstWidth = osd_profile->Width/5;
		blend_param.DstHeight = osd_profile->Height/5;
		blend_param.SaturateAlpha = 0;

		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_BlendAndScaleRectangles, &blend_param, sizeof(blend_param));
	}//*/

	gfx_waitkey(dcc_info, disp_opt);

#ifdef RMFEATURE_HAS_GRAPHACC_GRADIENTS
 	/* fill gradient */
	{
/* 		struct GFXEngine_RasterBlendGradient_type raster_param; */
		struct GFXEngine_LinearGradientSurface_type lin_gradient;
		struct GFXEngine_RadialGradientSurface_type rad_gradient;
		struct GFXEngine_FillReplaceGradient_type fill_grad_param;
		struct GFXEngine_BlendGradient_type blend_grad_param;

		rad_gradient.IntRadius = (osd_profile->Width/5)/8;
		rad_gradient.ExtRadius = (7*(osd_profile->Width/5))/8;
		rad_gradient.Color1 = 0x20ff0000;
		rad_gradient.Color0 = 0x80ffff00;
		rad_gradient.CenterX = 0;
		rad_gradient.CenterY = 0;
		rad_gradient.TransparentInt = FALSE;
		rad_gradient.TransparentExt = FALSE;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_RadialGradientSurface, &rad_gradient, sizeof(rad_gradient));

		fill_grad_param.Width = osd_profile->Width/5;
		fill_grad_param.Height = osd_profile->Height/5;
		fill_grad_param.DstX = 1*(osd_profile->Width/5);
		fill_grad_param.DstY = 2*(osd_profile->Height/5);
		fill_grad_param.AlphaX = 0;
		fill_grad_param.AlphaY = 0;
		fill_grad_param.Merge = FALSE;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_FillGradient, &fill_grad_param, sizeof(fill_grad_param));
		gfx_waitkey(dcc_info, disp_opt);

		lin_gradient.Width = osd_profile->Width/5;
		lin_gradient.Height = 0;
		lin_gradient.Color0 = 0x10ff0000;
		lin_gradient.Color1 = 0x80ffff00;
		SEND_GFX_COMMAND(dcc_info->pRUA, gfx, RMGFXEnginePropertyID_LinearGradientSurface, &lin_gradient, sizeof(lin_gradient));