osdbuf_control.c

Sample code for use on smp 863x processor.

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

/**
 * @file osdbuf_control.c
 * @brief application to control OSD buffers on 86XX
 * 
 * @author Julien Lerouge
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <getopt.h>

#define ALLOW_OS_CODE 1
#include "../dcc/include/dcc.h"
#include "common.h"
#include "osdlib.h"
#include "../rmcore/include/rmcore.h"
#include "../mambolfb/mambolfb.h"

/* For debug/verbose output */
#if 0
#define DEB(f) (f)
#else
#define DEB(f)
#endif

/* Default values */
#define DEFAULT_OSD_WIDTH 640
#define DEFAULT_OSD_HEIGHT 480
#define DEFAULT_OSD_COLOR_MODE EMhwlibColorMode_TrueColor
#define DEFAULT_OSD_COLOR_FORMAT EMhwlibColorFormat_32BPP
#define DEFAULT_OSD_CHIP 0

#define OSDGET_RUASP(pRUA, moduleID, propertyID, pValue, ValueSize)                                                    	\
{															\
	if (RMFAILED(get_osd_infos(&my_osd))){										\
		fprintf(stderr,"Error getting OSD buffer parameters.\n");						\
		goto wayout;												\
	}else if (my_osd.LumaSize == 0 && my_osd.ChromaSize == 0){							\
		fprintf(stderr,"No OSD buffer detected.\n");								\
		goto wayout;												\
	}else{														\
        	while ((status = RUASetProperty(pRUA, moduleID, propertyID, pValue, ValueSize, 0)) == RM_PENDING);	\
		DEB(fprintf(stderr,"Set property %d on module %ld, %d\n", propertyID, moduleID, status));		\
        	if (status != RM_OK) {                                                                                  \
        	        RMDBGLOG((ENABLE, "Cannot set Property %d on module %d, %d\n", propertyID, moduleID, status));  \
        	        goto wayout;                                                                                    \
        	}													\
	}														\
}

#define RUASP(pRUA, moduleID, propertyID, pValue, ValueSize)                           		                \
{														\
	while ((status = RUASetProperty(pRUA, moduleID, propertyID, pValue, ValueSize, 0)) == RM_PENDING);      \
	DEB(fprintf(stderr,"Set property %d on module %ld, %d\n", propertyID, moduleID, status));		\
	if (status != RM_OK) {                                                                                  \
		RMDBGLOG((ENABLE, "Cannot set Property %d on module %d, %d\n", propertyID, moduleID, status));  \
		goto wayout;                                                                                    \
	}													\
}


extern struct osd_format_string_s osd_color_mode_string[EMhwlibColorMode_TrueColorWithKey];
extern struct osd_format_string_s osd_color_format_string[EMhwlibColorFormat_16BPP_4444];

/* Globals*/
static struct display_cmdline disp_opt;
static RMuint32 command = 0;

static void print_osd_info(struct osd_descriptor *p_osd)
{
	if (p_osd == NULL)
		return;
	
	if (p_osd->LumaSize){
		DEB(fprintf(stderr,"LumaAddr :\n"));
		fprintf(stdout,"  videomemory=0x%08lx videomemorysize=%ld palette=0x%x mode=%ld:%ld:%ld\n",
		        p_osd->LumaAddr, p_osd->LumaSize, BASE_PALETTE, p_osd->profile.Width, p_osd->profile.Height, 
		        p_osd->bpp);
	}
	
	if (p_osd->ChromaSize){
		DEB(fprintf(stderr,"ChromaAddr :\n"));
		fprintf(stdout,"  videomemory=0x%08lx videomemorysize=%ld palette=0x%x mode=%ld:%ld:%ld\n",
		        p_osd->ChromaAddr, p_osd->ChromaSize, BASE_PALETTE, p_osd->profile.Width, p_osd->profile.Height, 
		        p_osd->bpp);
	}
	
	if (p_osd->ChromaSize == 0 && p_osd->LumaSize == 0){
		fprintf(stdout,"No persistent OSD buffer registered\n");
	}
}

/** Cleanup
 */
static void cleanup(void *param)
{
	RMstatus err;
	struct osd_descriptor *my_osd=(struct osd_descriptor *)param;

	if (my_osd == NULL)
		return;

	if (my_osd->dcc_info.pDCC){
		err = DCCClose(my_osd->dcc_info.pDCC);
		if (RMFAILED(err))
			fprintf(stderr, "Cannot close DCC %d\n", err); 
	}

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

	DEB(fprintf(stderr,"end cleanup\n"));
}



static void osdbuf_control_usage (RMascii *name)
{
	RMuint32 i;
	
	fprintf(stderr,
	        "Usage :\n"
	        "\t%s [DISPLAY OPTIONS] -c[withxheigt] [-F <format:subformat>]\n"
	        "\t\tto create an OSD buffer\n"
	        "\t%s -p\n"
	        "\t\tto print parameters suitable for mambolfb\n"
	        "\t%s -d\n"
	        "\t\tto delete current OSD buffer\n"
	        "\t%s -i\n"
	        "\t\tto get full info on current OSD buffer\n"
	        "\t%s -x <fb device>\n"
		"\t\tto bind the current OSD buffer to a frame buffer device\n"
	        "\t%s -X <fb device>\n"
	        "\t\tto unbind the current OSD buffer from a frame buffer device\n"
	        "\t%s [-k <r,g,b:range>] [-e <0|1>] [-t <2|4>] [-l <c:a>] \n"
	        "\t\t[-0 <level>] [-1 <level>] [-z <x,y>] [-a <0|1>] [-O <0|1>]\n"
	        "\t\t[-C <csc>]\n"
	        "\t\tto tune the OSD buffer\n\n",
 		name, name, name, name, name, name, name);
	show_display_options();
	fprintf(stderr,"\nOSD specific options :\n"
	        "\t-0 set alpha0 level\n"
	        "\t-1 set alpha1 level\n"
	        "\t-a enable/disable fading\n"
	        "\t-m chip number\n"
	        "\t-e activate direction estimation in adaptive scaler\n"
	        "\t-d delete current OSD buffer\n"
	        "\t-i get complete info on current buffer\n"
	        "\t-k set the key color to (r,g,b) with given range (0->15).\n"
	        "\t   Matching range for each component : [keycolor, keycolor + 2 ^ range [\n"
	        "\t-l set anti flicker level for color and alpha (color:alpha)\n"
	        "\t   0 (no filtering) -> 3 (strong filtering)\n"
	        "\t-c create a new OSD buffer of size widhtxheight (%dx%d by default)\n"
	        "\t-p get OSD parameters suitable for mambolfb\n"
	        "\t-t set the number of taps used by adaptive scaler\n"
	        "\t-O enable/disable the OSD channel\n"
	        "\t-F color mode : color format to use (default %s:%s) \n"
	        "\t   color modes (for lut or tc selection) :\n",
		DEFAULT_OSD_WIDTH, DEFAULT_OSD_HEIGHT,
		osd_color_mode_string[DEFAULT_OSD_COLOR_MODE].name,
		osd_color_format_string[DEFAULT_OSD_COLOR_FORMAT].name);
	for (i=1;i<=EMhwlibColorMode_TrueColorWithKey;i++)
		if (osd_color_mode_string[i].name[0])
			fprintf(stderr,"\t\t%-12s - %s\n",osd_color_mode_string[i].name, osd_color_mode_string[i].comment);
	fprintf(stderr,"\t   color formats (for pixel or lut format selection) :\n");
	for (i=1;i<=EMhwlibColorFormat_16BPP_4444;i++)
		if(osd_color_format_string[i].name[0])
			fprintf(stderr,"\t\t%-12s - %s\n",osd_color_format_string[i].name, osd_color_format_string[i].comment);
	 fprintf(stderr,
	        "\t-x Bind the OSD buffer to the given frame buffer device\n"
		"\t-X Unbind the OSD buffer from the given frame buffer device\n");
	fprintf(stderr,"\n");
	exit(EXIT_FAILURE);
}

static void parse_cmdline(int argc, char *argv[], struct osd_descriptor *osd)
{
	int i,j;
	RMstatus err;
	int args;
	int cs_set=0;

	if (osd == NULL)
		exit(EXIT_FAILURE);
	
	if (argc < 2) 
		osdbuf_control_usage(argv[0]);

	/* Init the default osd descriptor */
	osd->profile.SamplingMode = EMhwlibSamplingMode_444;
	osd->profile.ColorMode = DEFAULT_OSD_COLOR_MODE;
	osd->profile.ColorFormat = DEFAULT_OSD_COLOR_FORMAT;
	osd->profile.ColorSpace = EMhwlibColorSpace_RGB_0_255;
	osd->profile.PixelAspectRatio.X = 4;
	osd->profile.PixelAspectRatio.Y = 3;
	osd->dcc_info.route = DCCRoute_Main; 
	osd->dcc_info.disp_info->osd_enable[0] = TRUE;
	osd->chip_num = DEFAULT_OSD_CHIP;

	i = 1;
        while (i < argc) {
		j = i;
		err = parse_display_cmdline(argc, argv, &i, &disp_opt);
		if (err == RM_ERROR){
			fprintf(stderr,"Error parsing display options.\n");
			osdbuf_control_usage(argv[0]);
		}
		if (err == RM_PENDING)
			i++;
		if (err == RM_OK){
			RMint32 k;
			for (k = j; k <i; k++)
				argv[k]="-?";
		}
	}

	/* Check duplicate parameter name since -cs was added and customer want
	 * stable command usage ... */
	for (i=1 ; i<argc; i++){
		if (! strcmp("-cs",argv[i])){
			cs_set=1;
			osd->profile.ColorSpace = disp_opt.color_space;
			break;
		}
	}
	
	/* Ok, parse command line now */
	while (( i = getopt(argc,argv, "c::l:p?idF:k:e:t:0:1:z:a:O:C:x:X:")) != EOF )
		switch(i){
		case '?': //skip it
			break;
		case 'c':
			if (optarg){
				args = sscanf(optarg,"%lux%lu", &osd->profile.Width, &osd->profile.Height);
				if ( args == 2 )
					printf("OSD buffer size : %lux%lu\n",
					       osd->profile.Width,osd->profile.Height);
				else{
					printf("Error parsing OSD size\n");
					osdbuf_control_usage(argv[0]);
				}
			}else{
				osd->profile.Width = DEFAULT_OSD_WIDTH;
				osd->profile.Height = DEFAULT_OSD_HEIGHT;
			}
			command |= OSD_CREATE;
			break;
		case 'F':
			DEB(fprintf(stderr,"F param, optarg=%s\n",optarg));
			if (optarg){
				RMascii osd_color_mode_string[256];
				RMascii osd_color_format_string[256];
				args = sscanf(optarg,"%[^:]:%s",osd_color_mode_string,osd_color_format_string);
				if ( args == 2 && 
				     get_osd_color_mode(osd_color_mode_string, (RMuint32 *)&osd->profile.ColorMode) &&
				     get_osd_color_format(osd_color_format_string, (RMuint32 *)&osd->profile.ColorFormat)){
					printf("OSD format : %s:%s\n",osd_color_mode_string, osd_color_format_string);
					command |= OSD_SET_FORMAT;
					break;
				}
			}
			printf("Error parsing OSD format\n");
			osdbuf_control_usage(argv[0]);
			break;
		case 'p':
			command |= OSD_GET_PARAMS;
			break;
		case 'd':
			command |= OSD_DEL;
			break;
		case 'i':
			command |= OSD_GET_INFOS;
			break;
		case 'm':
			args = sscanf(optarg,"%ld",&osd->chip_num);
			if ( args == 1 )
				printf("OSD chip number : %ld",osd->chip_num);
			else{
				printf("Error parsing chip number\n");
				osdbuf_control_usage(argv[0]);
			}
			break;
		case 'k':
			args = sscanf(optarg,"%lu,%lu,%lu:%lu", &osd->kcolor.R_Cr, 
				      &osd->kcolor.G_Y, &osd->kcolor.B_Cb, 
				      &osd->kcolor.Range); 
			if ( args == 4 ){
				CROP(osd->kcolor.Range,8);
				CROP(osd->kcolor.R_Cr,255);
				CROP(osd->kcolor.G_Y,255);
				CROP(osd->kcolor.B_Cb,255);
				printf("Key color (R/Cr,G/Y,B/Cb) : [%lu,%lu[, [%lu,%lu[, [%lu,%lu[\n", 
				       osd->kcolor.R_Cr, 
				       CROPV(osd->kcolor.R_Cr+(1<<osd->kcolor.Range), 256),
				       osd->kcolor.G_Y, 
				       CROPV(osd->kcolor.G_Y+(1<<osd->kcolor.Range), 256),
				       osd->kcolor.B_Cb,
				       CROPV(osd->kcolor.B_Cb+(1<< osd->kcolor.Range), 256));
				command |= OSD_SET_KCOLOR;
			}else{
				printf("Error parsing key color\n");
				osdbuf_control_usage(argv[0]);
			}
			break;
		case 'e':
			{
				RMuint32 tmp;
				args = sscanf(optarg,"%lu",&tmp);
				if ( args != 1 ){
					printf("Error parsing adaptive parameter\n");
					osdbuf_control_usage(argv[0]);
				}
				CROP(tmp,1);
				osd->scaling_config.AdaptativeEnable = (RMbool) tmp;
				printf("Direction estimation : %s\n", osd->scaling_config.AdaptativeEnable ?
				       "enabled" : "disabled");
				command |= OSD_SET_ADAPT;
			}
			break;
		case 't':
			args = sscanf(optarg,"%ld",&osd->scaling_config.Taps);
			if ( args != 1 || ( osd->scaling_config.Taps != 2 && osd->scaling_config.Taps != 4 ) ){
				printf("Error parsing taps parameter\n");
				osdbuf_control_usage(argv[0]);
			}
			osd->scaling_config.Taps = ( osd->scaling_config.Taps >> 1 ) - 1;
			printf("Taps : %d\n",osd->scaling_config.Taps ? 4 : 2);
			command |= OSD_SET_TAPS;
			break;
		case 'l':
			args = sscanf(optarg,"%ld:%ld",&osd->scaling_config.AntiFlickerColor,
				      &osd->scaling_config.AntiFlickerAlpha);
			if ( args != 2){
				printf("Error parsing anti flicker parameters\n");
				osdbuf_control_usage(argv[0]);
			}
			CROP(osd->scaling_config.AntiFlickerColor,3);
			CROP(osd->scaling_config.AntiFlickerAlpha,3);
			printf("Color Anti Flicker : %ld\n",osd->scaling_config.AntiFlickerColor);
			printf("Alpha Anti Flicker : %ld\n",osd->scaling_config.AntiFlickerAlpha);
			command |= OSD_SET_ANTIF;
			break;