gfx_demo.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 "bitmaps.h"
#include "gfx_demo.h"

#define KEYFLAGS (SET_KEY_DISPLAY | SET_KEY_PLAYBACK)
#define TIMEOUT_US 10000
#define MAX_SCALERS 5

static RMuint32 bitmap_addr = 0, circle_addr = 0, logo_addr = 0, gfx = 0, buf_addr = 0;
static struct DCCOSDProfile bitmap_profile;
static RMuint32 scalers[MAX_SCALERS] = {DispOSDScaler,};
static RMuint32 scaler_count = 0;
static struct RUA *pRUA = NULL;
static RMbool end = FALSE;
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,};
RMuint32 inv_speed = 1;

													
#define SEND_GFX_COMMAND(propertyID, pValue, ValueSize)				                \
{												\
	RMstatus err;										\
	do{											\
		err = RUASetProperty(pRUA, gfx, propertyID, pValue, ValueSize, 0);		\
		if ((err == RM_PENDING)) {							\
 			struct RUAEvent evt;							\
			evt.ModuleID = gfx;				         		\
			evt.Mask = RUAEVENT_COMMANDCOMPLETION;					\
			RUAWaitForMultipleEvents(pRUA, &evt, 1, TIMEOUT_US, NULL);		\
		}										\
		if(!user_command())								\
			end = TRUE;								\
	}while((err == RM_PENDING) && (end == FALSE));								\
	if (err != RM_OK) {									\
		RMDBGLOG((ENABLE, "Can't send command to command fifo\n" ));			\
		end = TRUE;									\
	}											\
											   	\
}





static RMuint32 multiple_readers = FALSE;


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 RMuint32 user_command(){
	RMascii key;

	if (RMKeyAvailable()) {
		key = RMGetKey();
		switch(key){
		case 'q':
		case 'Q':
			return 0;
		case ' ':
			DCCSTCStop(dcc_info.pStcSource);
			break;
		case 'P':
		case 'p':
			DCCSTCPlay(dcc_info.pStcSource);
			break;
		case '+':
			inv_speed = RMmax(1, inv_speed-1);
			DCCSTCSetSpeed(dcc_info.pStcSource, 1, inv_speed);
			break;
		case '-':
			inv_speed = RMmin(8, inv_speed+1);
			DCCSTCSetSpeed(dcc_info.pStcSource, 1, inv_speed);
			break;
		}
		return 1;
	}
	return 2;

}
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++;
				continue;
			}
			else
				show_usage(argv[0]);
		}

		if (! strcmp(argv[i], "-oscaler")) {
			if (argc > i+1) {
				if (! strcmp(argv[i+1], "osd")) {
					scalers[scaler_count] = EMHWLIB_MODULE(DispOSDScaler,0);
					scaler_count++;
				}
				else if (! strcmp(argv[i+1], "vp")) {
					scalers[scaler_count] =  EMHWLIB_MODULE(DispVideoPlane,0);
					scaler_count++;
				}
				else if (! strcmp(argv[i+1], "vcr")) {
					scalers[scaler_count] = EMHWLIB_MODULE(DispVCRMultiScaler,0);
					scaler_count++;
				}
				else if (! strcmp(argv[i+1], "crt")) {
					scalers[scaler_count] = EMHWLIB_MODULE(DispCRTMultiScaler,0);
					scaler_count++;
				}
				else if (! strcmp(argv[i+1], "main")) {
					scalers[scaler_count] = EMHWLIB_MODULE(DispMainVideoScaler,0);
					scaler_count++;
				}
				else
					show_usage(argv[0]);
				i+=2;
				continue;
			}
			else
				show_usage(argv[0]);
		}

		if (! strcmp(argv[i], "-multiple_readers")) {
			multiple_readers = TRUE;
			i++;
			continue;
		}

		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 RMstatus init_scaler(struct DCC *pDCC, struct RUA *pRUA, struct DCCVideoSource *pVideoSource, RMuint32 osd_scaler)
{
	RMbool enable = TRUE;
	struct EMhwlibDisplayWindow window;
	enum EMhwlibMixerSourceState state;
	RMuint32 mixer, src_index = 0, canvas_alpha = 0x80;
	struct RUAEvent e;
	RMuint32 index;
	static RMuint32 window_counter = 0;
	RMstatus err;
	
	mixer = DispMainMixer;
	
	window.X = 2048;
	window.Y = 2048;
	window.Width = (4-window_counter) * 1024;
	window.Height = (4-window_counter) * 1024;

	window_counter = (window_counter + 1) % 4;
	
	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 = RUAExchangeProperty(dcc_info.pRUA, mixer, RMGenericPropertyID_MixerSourceIndex, &osd_scaler, sizeof(osd_scaler), &src_index, sizeof(src_index));
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get scaler index\n"));
		return err;
	}
	mixer = EMHWLIB_TARGET_MODULE(mixer, 0, src_index);
	
	
	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 %d\n", err));
		return err;
	}

	state = EMhwlibMixerSourceState_Master;
	while((err =  RUASetProperty(dcc_info.pRUA, mixer, RMGenericPropertyID_MixerSourceState, &state, sizeof(state), 0))==RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set scaler's state on mixer\n"));
		return err;
	}
	
	while ((err = RUASetProperty(dcc_info.pRUA, mixer, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot Validate mixer\n"));
		return err;
	}
	
	while( (err = RUASetProperty(dcc_info.pRUA, osd_scaler, RMGenericPropertyID_Alpha0, &(canvas_alpha), sizeof(canvas_alpha), 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set the alpha value on the scaler\n"));
	}
	
	while ((err = RUASetProperty(dcc_info.pRUA, osd_scaler, RMGenericPropertyID_Enable, &enable, sizeof(enable), 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot validate scaler input window %d\n", err);
		return err;
	}

	if (osd_scaler != DispVideoPlane) {
		window.X = 0;
		window.Y = 0;
		window.Width = 4096;
		window.Height = 4096;
		window.XPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
		window.YPositionMode = EMhwlibDisplayWindowPositionMode_FrontEdgeToBorder;
		window.XMode = EMhwlibDisplayWindowValueMode_Relative;
		window.YMode = EMhwlibDisplayWindowValueMode_Relative;
		window.WidthMode = EMhwlibDisplayWindowValueMode_Relative;
		window.HeightMode = EMhwlibDisplayWindowValueMode_Relative;
		while ((err = RUASetProperty(dcc_info.pRUA, osd_scaler, RMGenericPropertyID_ScalerInputWindow, &window, sizeof(window), 0)) == RM_PENDING);
		if (RMFAILED(err)) {
			fprintf(stderr, "Cannot validate scaler input window %d\n", err);
			return err;
		}
	}
	
	err = DCCSetSurfaceSource(dcc_info.pDCC, osd_scaler, pVideoSource);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot set the surface source %d\n", err);
		return RM_ERROR;
	}
	
	err = DCCEnableVideoSource(pVideoSource, TRUE);
	if (RMFAILED(err)){
		fprintf(stderr,"Error enabling OSD buffer : %d\n",err);
		return err;
	}

	while ((err = RUASetProperty(dcc_info.pRUA, osd_scaler, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot validate scaler input window %d\n", err);
		return err;
	}
	
	e.ModuleID = EMHWLIB_MODULE(DisplayBlock, 0);
	e.Mask = EMHWLIB_DISPLAY_EVENT_ID(osd_scaler);
	err = RUAWaitForMultipleEvents(pRUA, &e, 1, 1000000, &index);
	if (err == RM_ERROR) {
		fprintf(stderr, "cannot wait for the scaler to refresh\n");
		return err;
	}
	
	return RM_OK;
}


/* load the bitmap specfied on the commandline, and all that's on gfx_demo.h */
static RMstatus load_bitmaps()
{
	struct RMBitmapFileInfo bfi;
	struct RMBitmapFileOptions opts;
	RMuint8 *buf_map;
	RMuint32 buf_size, bitmap_size;
	RMstatus err;
		
	opts.alpha = 0x80;
	opts.force_rgb = TRUE;
		
	err = RMOpenBitmapFile(filename, &bfi, &opts, &bitmap_profile);
	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "Error opening file %s\n", filename));
			return err;
	}
	
	if (bitmap_profile.ColorMode != EMhwlibColorMode_TrueColor){
		fprintf(stderr, "Image should be true color\n");
		return -1;
	}

	bitmap_size = 4*bitmap_profile.Width*bitmap_profile.Height;
	buf_size = bitmap_size + sizeof(circle_pix) + sizeof(logo_pix) + sizeof(glyph_points);
	buf_addr = RUAMalloc(pRUA, 0, RUA_DRAM_UNCACHED, buf_size);
	
	bitmap_addr = buf_addr;
	logo_addr   = buf_addr + bitmap_size;
	circle_addr = buf_addr + bitmap_size + sizeof(logo_pix);
	elephant_glyph.GlyphAddr = buf_addr + bitmap_size + sizeof(logo_pix) + sizeof(circle_pix);
		
	elephant_glyph.OutAddr = RUAMalloc(pRUA, 0, RUA_DRAM_UNCACHED, 192*192/8); /*128x128@1bpp*/
		
	err = RUALock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error locking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}
	buf_map = RUAMap(pRUA, buf_addr, buf_size);
	if (buf_map == NULL) {
		RMDBGLOG((ENABLE, "Error mapping OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return RM_ERROR;
	}
		
	RMBitmapToRaw(buf_map, NULL, &bfi);
	RMMemcpy(buf_map + bitmap_size, logo_pix, sizeof(logo_pix));
	RMMemcpy(buf_map + bitmap_size + sizeof(logo_pix), circle_pix, sizeof(circle_pix));
	RMMemcpy(buf_map + bitmap_size + sizeof(logo_pix) + sizeof(circle_pix), glyph_points,  sizeof(glyph_points));
	
	RUAUnMap(pRUA, buf_map, buf_size);
	err = RUAUnLock(pRUA, buf_addr, buf_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error unlocking OSD buffer at 0x%08lX (0x%08lX bytes)\n", buf_addr, buf_size));
		return err;
	}
	
	RMCloseBitmapFile(&bfi);
	return RM_OK;
}

/* 
   disclaimer: when this function was frist written, readaility was not the 
   main goal, and unfortunately hasn't been rewritten since. work is in progress.
*/
static void gfx_demo_draw_picture(RMuint32 pic_luma, RMuint32 pic_index)
{
	static struct GFXEngine_Surface_type YZ_surface;
	static struct GFXEngine_Surface_type X_surface;
	static struct GFXEngine_ColorFormat_type format;
	static struct GFXEngine_AlphaFormat_type alpha_format;
	static struct GFXEngine_AlphaPalette_type alpha_palette;
	static struct GFXEngine_Palette_2BPP_type color_palette;
	static struct GFXEngine_Palette_1BPP_type color_palette_1bpp;
	static struct GFXEngine_MoveReplaceScaleRectangle_type circle_move;
	static struct GFXEngine_BlendRectangles_type blend;
	static struct GFXEngine_MoveReplaceRectangle_type move;
	static struct GFXEngine_SingleColorBlendRectangles_type sc_blend;
	static RMuint32 last_x[2];
	static RMuint32 last_y[2];
	static RMuint32 x,  y , i;
	static RMint32 x_inc, y_inc, size_inc, alpha_inc;
	static RMuint32 size;
	static RMuint32 state;