How to display in 16:9 aspect ratio

Developing widescreen applications

/**************************************************
* Filename:	cdi_16_9.c
* Purpose:	MeMo plugin to support 16:9 <--> 4:3 switching
* Arguments:	'0' or '1'
*   			'0' will switch the Aspect Ratio to 4:3
*        		'1' will switch the AR to 16:9
* Returns:  	On Error it will exit with error code 1 AND
*           	will set the Media Mogul variable Z to 999.
*
*  If you have set 16:9 to ON in the player shell
*  AND
*  Your CD-i player is connected to the TV (that supports 16:9) 
*  by Euro AV plug 
*  THEN
*  This plugin will switch the AR 
**************************************************/
#include 
#include 
#include  
#include  

#define SYSERR                  (-1)

/* globals */
int vpath, armode;


/*******************
* Function to set the Media Mogul Variable 'Z' to '999'.
* This is done to let Media Mogul know the plugin failed.
* It will return a 1 on Error.
*******************/
Set_MeMo_varZ()
{
int zd, value_z, result;

zd = _ev_link("Z");
if (zd == SYSERR)
	{
	return(1);
	}
value_z = 999;
result = _ev_set(zd, value_z, 0);
if (result == SYSERR)
	{
	return(1);
	}
result = _ev_unlink(zd);
if (result == SYSERR)
	{
	return(1);
	}
return(0);
}
/**************************************************
* main()
**************************************************/
main( argc, argv )
int argc;
char **argv;
{
 int i;
 char *devnam, *parstr;

 /* check if a '1' (set to 16:9) or '0' (set to 4:3) is given */
 if (argc < 2) 
	{
	/* argc < 2 */
	i = Set_MeMo_varZ();
	exit(1); 
	}
 armode = atoi(argv[1]);
 if ((armode != 0) && (armode != 1)) 
	{
	/* illegal ARmode */
	i = Set_MeMo_varZ();
	exit(1); 
	}

 /* open video path */
 if ((devnam = csd_devname(DT_VIDEO,1)) == NULL)
	{
	/* can not get video path */
	free(devnam);
	i = Set_MeMo_varZ();
	exit(1);
	}
 if ((vpath = open(devnam, S_IREAD | S_IWRITE)) == SYSERR) 
	{
	/* can not open video path */
	free(devnam);
	i = Set_MeMo_varZ();
	exit(1); 
	}
 free(devnam);

 /* read csd entry string */
 if ((devnam = csd_devname(DT_DISPLY,1)) == NULL)
	{
	/* can not get Display Monitor path */
	free(devnam);
	i = Set_MeMo_varZ();
	exit(1);
	}
 if ((parstr = csd_devparam(devnam)) == NULL) 
	{
	/* can not get Display Monitor string */
	free(devnam);
	free(parstr);
	i = Set_MeMo_varZ();
	exit(1); 
	}
 free(devnam);
 i = findstr(1, parstr, "AR=\"16:9\"");
 free(parstr);
 if (i == 0) 
	{
	/* armode not set to 16:9 in CSD file (in player shell) */
	i = Set_MeMo_varZ();
	exit(1); 
	}

 /* switch AR */
 i = SetAR();
 if (i == SYSERR) 
	{
	/* set AR failed */
	i = Set_MeMo_varZ();
	exit(1); 
	}
 /* set AR succeeded */
 exit(0);
}


#asm

* Function to switch the Aspect Ratio.
* This function needs two GLOBAL variables          
* 'int vpath, armode' with exactly these names.    
* In 'vpath' it needs the video path              
* and in 'armode' it needs the argument passed.
* This may have only the values '0' or '1'.      
* '0' will switch the AR to 4:3 and            
* '1' will switch the AR to 16:9.             
* The function will return SYSERR (-1) if it failed
* and OK (0) if it could switch the AR.

DC_SetAR		equ		$20 

SetAR:		movem.l	d2-d3,-(a7)
			move.l	vpath(a6),d0	
			move.w	#SS_DC,d1
			move.w	#DC_SetAR,d2
			move.l	armode(a6),d3
			OS9		I$SetStt
			bcs.s	ERROR
			moveq	#0,d0
			movem.l	(a7)+,d2-d3
			rts
ERROR		moveq	#-1,d0
			movem.l	(a7)+,d2-d3
			rts

#endasm

Media Mogul Keypads

Makes Kiosk Applications User Friendly

CD-i Keyboard

example codes

/**************************************************
*
*
*   CDI KEYBOARD example code...
*
*
*   programmer 	: Jan Matejka, Philips Int. Media
*   platform 	: CD-i
*   compiler	: Microware OS9 C compiler V3.2.3 for Sun/Sparc 
*
/*************************************************/

#include 
#include 
#include 
#include 
#include   
#include 
#include 
#include 
#include 

#include "cdm.h"
#include "debug.h"


#define		SCAN_SIG		280

/* KEYBOARD DEFINITIONS	*/
#define		KEYBOARD_SIG		300

#define		KB_MODE_WAIT		0x01
#define		KB_MODE_REMOVE		0x02

#define		KB_KEY_PRESSED		0x01
#define		KB_KEY_AUTO_REPEAT	0x02
#define		KB_KEY_RELEASED		0x04

/*	globals		*/
extern int	errno;


int		keyboard_path;

unsigned short	kb_ok_flag;

short		inkey;
unsigned char	type;

char		character[1];


void		init_kb();
void		flush_keyboard_buffer();
void		signal_handler();


/*************************************************/

main()
{


init_kb();
intercept(signal_handler);
kb_ssig(keyboard_path, KEYBOARD_SIG);
dc_ssig(video_path,SCAN_SIG,0);



while(1);

exit(0);
}

/*************************************************/



//************************************************/

void init_kb()
{
char *kb_devname;

	if ((kb_devname = csd_devname(DT_KEYBRD, 1)) == NULL)
		{
		DEBUG_ON(printf("CSD Error on keyboard name\n");)
		kb_ok_flag = 0;
		}
		else 
		{
		if ((keyboard_path = open(kb_devname, S_IREAD)) == -1)
			{
			DEBUG_ON(printf("Error on opening keyboard\n");)
			kb_ok_flag = 0;
			}
			else
			{
			kb_ok_flag = 1;
			kb_repeat(keyboard_path,25,5); 	/* default auto-repeat is on, delay time : 25 ticks, repeat time : 5 ticks */
			flush_keyboard_buffer();
			}
		}
}

/*************************************************/

void	flush_keyboard_buffer()
{
short		inkey;
unsigned char	type;

	if (kb_ok_flag)
		{
		do kb_read(keyboard_path,KB_MODE_REMOVE,&inkey,&type);
			while (type);
		Wait_n_Ticks(2);
		do kb_read(keyboard_path,KB_MODE_REMOVE,&inkey,&type);
			while (type);
		}
}

	
/**************************************************
* SIGNAL_HANDLER						*
**************************************************/

void signal_handler(signum)
register int 	signum;
{

switch(signum)
	{

	case	KEYBOARD_SIG:
		kb_read(keyboard_path,KB_MODE_REMOVE,&inkey,&type);
		printf("inkey : %d --- type : %d\n",inkey,type);
		if (type & (KB_KEY_PRESSED | KB_KEY_AUTO_REPEAT) )
			{
			if (scan_count<40)
				{
				printf("hello...\n");
				scan_count++;
				}
			}

		kb_ssig(keyboard_path, KEYBOARD_SIG);
		break;

	case	SCAN_SIG:
		dc_ssig(video_path,SCAN_SIG,0);
		break;

	case SIGQUIT:
	case SIGINT:
		exit(0);

	default:
		DEBUG_ON(printf("Signal_Handler: Unknown signal [%d]\n", signum););
	}
}
/*************************************************/

Electronic CD-i catalogue

Your publicity for free

CD-i Training Courses

Launcher program

An example

/******************************************************************************
* Filename:		launcher.c
* Purpose:		This is the application that is initially loaded by the player
*				shell; it then loads the actual application and
*				chains to it, having first decremented its own link count.
*				after it has run the philips bumper
******************************************************************************/
#include <memory.h>
#include <module.h>
#include <modes.h>
#include <ucm.h>
#include <csd.h>
#include <cdfm.h>
#include <bumper.h>
#include <rtr.h>


#define BUMP_LCT_HEIGHT		480	
#define	BUMP_ARGNUM		2	/* Max number of bumper cmd line args */
#define	VOLUME_UP		0x00000000

#define APPLICATION_NAME        "cdi_main"
#define APPLICATION_NAME_NODV   "cdi_main2"
 

extern int errno;			/* Needed externals */
extern int os9forkc();
extern char **environ;

char *argblk[BUMP_ARGNUM] = {"cdi_bumper", 0};
char *argblk1[] = {APPLICATION_NAME, 0};
char *argblk2[] = {APPLICATION_NAME_NODV, 0};
char *bumpdata = "cdi_bumpdata";

extern int os9exec(), chainc();
 
/******************************************************************************
* main()
******************************************************************************/
main( argc, argv )
int argc;
char **argv;
{
	int vpath;
	int f0, f1, pid, waitpid;
	unsigned int bumper_status;
	mod_exec *datmod, *modlink(), *modcload();
	BUMPER_DATA *bumpmod;
	char cdnam[10], applic_mod_name[64], *devnam;

	errno = 0;

 	/* Load the bumper executable and data module */
	if ( (int)modcload( argblk[0], 0, VIDEO1) == SYSERR )
		exit( errno );

	/* Link to the data module */
	if ( (int)(datmod = modlink( bumpdata, MT_ANY )) == SYSERR )
		if ( (int)(datmod = modcload( bumpdata, 0, VIDEO1 )) == SYSERR )
			exit( errno );

	/* Point to the actual data section of the module */
	bumpmod = (BUMPER_DATA *)((char *)datmod + ((DATA_MODULE *)datmod)->data_offset);

	/* Get video environment setup */
	if ( bump_init_vid( &vpath, &(bumpmod->dcp), 
				BUMP_LCT_HEIGHT, bumpmod->vid_name ) == SYSERR )
		exit( errno );

	if ( (devnam = csd_devname(DT_VIDEO,1)) == NULL )
            exit(errno);
      if ( (vpath = open( devnam, S_IREAD )) == SYSERR )
            exit( errno );
      free( devnam );
      gc_hide(vpath);

	/* Remember height of LCTs */
	bumpmod->lct_height = BUMP_LCT_HEIGHT;
	init_audio();			/* Set up audio so it plays */

	/* Set compat bit and PAL flag */
	if ( set_comp_mode( vpath, &(bumpmod->pal_flag) ) == SYSERR )
		exit( errno );

	/* Null these out, assume we don't pass */
	bumpmod->app_pa_buf = NULL;
	bumpmod->app_pb_buf = NULL;
	bumpmod->pcb = NULL;

	/* Shut down the planes then execute DCP */
	dc_wrfi( vpath, bumpmod->dcp.fcta, FCT_ICF, cp_icf(PA, ICF_MIN) );
	dc_wrfi( vpath, bumpmod->dcp.fctb, FCT_ICF, cp_icf(PB, ICF_MIN) );
	dc_exec( vpath, bumpmod->dcp.fcta, bumpmod->dcp.fctb );

      /* Fork the Bumper */
      if ( (pid = os9exec( os9forkc, argblk[0], argblk, environ,
						 0, 0, (vpath + 1) )) == SYSERR )
                exit( errno );
      do
                {
                waitpid = wait( &bumper_status );
                }
      while ((waitpid != -1) && (waitpid != pid)); /* wait for bumper to finisch */
	while (munload( bumpdata, 0)!=-1);	/* Decrement the data module's link count */

/*
 * This concludes what is necessary for the bumper
 * itself to run; From here on down it's strictly
 * application.  
 */

        gc_hide(vpath);
        f0 = dc_crfct( vpath, PA, 3, 0);
        if (f0 == -1) exit(errno);
        dc_wrfi( vpath, f0, 0, cp_tci(MIX_OFF, TR_ON, TR_ON) );
        dc_wrfi( vpath, f0, 1, cp_bkcol(BK_LOW, BK_BLACK) );
        dc_wrfi( vpath, f0, 2, cp_icm(ICM_OFF, ICM_OFF, NM_1, EV_OFF, CS_A) );
        f1 = dc_crfct( vpath, PB, 3, 0);
        if (f1 == -1) exit(errno);
        dc_wrfi( vpath, f1, 0, cp_tci(MIX_OFF, TR_ON, TR_ON) );
        dc_wrfi( vpath, f1, 1, cp_bkcol(BK_LOW, BK_BLACK) );
        dc_wrfi( vpath, f1, 2, cp_icm(ICM_OFF, ICM_OFF, NM_1, EV_OFF, CS_A) );
        dc_exec( vpath, f0, f1 );

	  if ( (int)(devnam = csd_devname( DT_CDC, 1)) == -1 )
		    exit(errno);
	  strcpy(cdnam, devnam);
	  strcpy ( applic_mod_name, cdnam);
	  strcat ( applic_mod_name, "/");
        free( devnam );
        if(csd_devname(90,1)!=NULL) /* is there a DV cartridge */
          { /* goto cdi_main (that needs DV) with a black screen */
		if ((int)modlink("vcd", MT_ANY) != SYSERR)
			{
			 /* DV cartridge is Green book AND White book compatible */
			}
		else
			{
			/* DV cartridge is NOT White book compatible
			   Plays all MPEG as defined by the Green book */
			}
            strcat ( applic_mod_name, APPLICATION_NAME);
		/* you can change the memory colour to the colour you want 
		   your application to be loaded in */
            modcload(applic_mod_name,0,SYSRAM); 
            os9exec(chainc,argblk1[0],argblk1, environ, 0, 0, (vpath + 1));
        	exit(0);                        /* Git outta here */
          }
	  else
		{/* go to cdi_main2 (that needs no DV) with a black screen */
		 strcat ( applic_mod_name, APPLICATION_NAME_NODV);
		/* you can change the memory colour to the colour you want 
		   your application to be loaded in */
		 modcload(applic_mod_name,0,VIDEO1);
		 os9exec(chainc,argblk2[0],argblk2, environ, 0, 0, (vpath + 1));
		 exit(0);			/* Git outta here */
		}
}


/************************************************************************
* set_comp_mode()
*
* Purpose: 	Set the compatability mode on the CD-I system assuming
*				that the images used are 384 actual bytes wide
* Passed:	the video device number,
*			a ptr to the var which will contain the PAL flag,
* Output:	The compatability mode will be set according to the info
*				found in the CSD,
*			If we are displaying on a 625 line system, the pal_flag will
*				be set to YES, else it will be NO
* Returned:	OK or SYSERR
************************************************************************/
int set_comp_mode( vpath, pal_flag )
int vpath, *pal_flag;
{
	char *disp_dev, *disp_param;
	char *csd_devname(), *csd_devparam();
	REG char *dp;
	int mode, org_diff;

#define TV_TYPE_STR		"TV"	/* TV type ID string */
#define PAL_625_STR		"625"	/* Spec's 625 line system */

	if ( (disp_dev = csd_devname( DT_VIDEO, 1 )) == NULL )
		return ( SYSERR );

	if ( (disp_param = csd_devparam( disp_dev )) == NULL )
	{
		free( disp_dev );
		return ( SYSERR );
	}

	mode = 1;					/* Mode 1 is for 384 width on Monitor */
	dp = disp_param; 			/* If "TV" is found then mode should be 0 */
	while ( *dp != '\0' )
	{
		if (strncmp( dp++, TV_TYPE_STR, strlen(TV_TYPE_STR) ) == 0) 
		{
			mode = 0;
			break;
		}
	}

	*pal_flag = NO;				/* Assume NTSC */
	dp = disp_param; 			/* If 625 is found, then we are in PAL */
	while ( *dp != '\0' )
	{
		if (strncmp( dp++, PAL_625_STR, strlen(PAL_625_STR) ) == 0) 
		{
			*pal_flag = YES;
			if ( mode == 1 )	/* Need mode to be 0 w/384x240 on 625 lines */
				mode = 0;
			break;
		}
	}

	free( disp_dev );			/* Give back memory for csd stuff */
	free( disp_param );
								/* Set appropriate compatability mode */
								/*  and set return value to parameter */
	Errchk( org_diff = dc_setcmp( vpath, mode ) );

								/* Reset ptr to report from offset */
								/* Also, if in PAL, move org down 40 lines */
	pt_org( vpath, (org_diff >> 16), (org_diff & 0xff) );

	return ( OK );

#undef TV_TYPE_STR
#undef PAL_625_STR

}

/************************************************************************
* init_audio()
* Purpose:	Open up the audio device and set the attenuation to its 
*			initial full on value.
************************************************************************/
init_audio()
{
	int apath;
	char *aud_dev;

	errno = 0;
	if ((aud_dev = csd_devname( DT_AUDIO, 1 )) == NULL )
		return( SYSERR );

	apath = open( aud_dev, (S_IREAD | S_IWRITE));
	free( aud_dev );

	sc_atten( apath, VOLUME_UP );
}

The Interactive Engineer