osdlib.c

Sample code for use on smp 863x processor.

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

/**
 * @file osdbuf_control.c
 * @brief libray 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 <getopt.h>

#define ALLOW_OS_CODE 1

#include "osdlib.h"

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

struct osd_format_string_s osd_color_mode_string[EMhwlibColorMode_TrueColorWithKey+1] = {
	{"",""},
	{"lut1bpp", "clut with 1bpp"},
	{"lut2bpp", "clut with 2bpp"},
	{"lut4bpp", "clut with 4bpp"},
	{"lut8bpp", "clut with 8bpp"},
	{"tc", "true color"},
	{"tck", "true color with alpha key"},
};

struct osd_format_string_s osd_color_format_string[EMhwlibColorFormat_16BPP_4444+1] = {
	{"",""},
	{"24bpp_565","24 bpp 5:6:5 (alpha0)"},
	{"24bpp","24 bpp 8:8:8 (alpha0)"},
	{"32bpp_4444","32 bpp 4:4:4:4"},
	{"32bpp","32 bpp 8:8:8:8"},
	{"16bpp_565","16 bpp 5:6:5 (alpha0)"},
	{"16bpp_1555","16 bpp 1:5:5:5 (alpha0 or alpha1)"},
	{"16bpp_4444","16 bpp 4:4:4:4"}
};

struct osd_format_string_s osd_csc[EMhwlibColorSpace_YUV_709+1] = {
	{"", ""},
	{"rgb_16_235","RGB 16 235"},
	{"rgb_0_255","RGB 0 255"},
	{"yuv_601","YUV 601"},
	{"yuv_709","YUV 709"},
};

#define RUASP(pRUA, moduleID, propertyID, pValue, ValueSize)                                                    \
        while ((status = RUASetProperty(pRUA, moduleID, propertyID, pValue, ValueSize, 0)) == RM_PENDING);         \
                                                                                                                \
        if (status != RM_OK) {                                                                                     \
                RMDBGLOG((ENABLE, "Cannot set Property %d on module %d, %d\n", propertyID, moduleID, status));     \
                return status;                                                                                     \
        }

#define RUAGP(pRUA, moduleID, propertyID, pValue, ValueSize)                                                    \
        while ((status = RUAGetProperty(pRUA, moduleID, propertyID, pValue, ValueSize)) == RM_PENDING);         \
                                                                                                                \
        if (status != RM_OK) {                                                                                     \
                RMDBGLOG((ENABLE, "Cannot get Property %d on module %d, %d\n", propertyID, moduleID, status));     \
                return status;                                                                                     \
        }

#define RUAEP(pRUA, moduleID, propertyID, pValueIn, ValueInSize, pValueOut, ValueOutSize)                       \
        while ((status = RUAExchangeProperty(pRUA, moduleID, propertyID, pValueIn, ValueInSize,			\
	                                     pValueOut, ValueOutSize)) == RM_PENDING);         			\
                                                                                                                \
        if (status != RM_OK) {                                                                                     	\
                RMDBGLOG((ENABLE, "Cannot exchange Property %d on module %d, %d\n", propertyID, moduleID, status));     \
                return status;                                                                                     	\
        }



/** Print infos on the given OSD
 * @param p_osd - filled osd_descriptor
 * @return void
 */
void print_osd_full_info(struct osd_descriptor *p_osd)
{
	RMuint32 range = 1 << p_osd->kcolor.Range;
	RMuint32 end_r = p_osd->kcolor.R_Cr + range;
	RMuint32 end_g = p_osd->kcolor.G_Y + range;
	RMuint32 end_b = p_osd->kcolor.B_Cb + range;
	
	if (p_osd == NULL )
		return;
	if (p_osd->LumaAddr){
		fprintf(stdout,"Persistent OSD at 0x%08lX with %7lu bytes\n",
		        p_osd->LumaAddr, p_osd->LumaSize);

		/* FIXME some properties are missing*/
		fprintf(stdout,"Format                    : %s:%s\n", osd_color_mode_string[p_osd->profile.ColorMode].name,
		        osd_color_format_string[p_osd->profile.ColorFormat].name);
		fprintf(stdout,"Resolution                : %ldx%ld\n", p_osd->profile.Width, p_osd->profile.Height);
		fprintf(stdout,"Color Space Conversion    : %s\n", osd_csc[p_osd->profile.ColorSpace].comment);
		fprintf(stdout,"Input Resolution          : %ldx%ld\n", p_osd->input_window.Width, p_osd->input_window.Height);
		fprintf(stdout,"Taps                      : %d\n", p_osd->scaling_config.Taps ? 4 : 2);
		fprintf(stdout,"Anti Flicker Color        : %ld\n", p_osd->scaling_config.AntiFlickerColor);
		fprintf(stdout,"Anti Flicker Alpha        : %ld\n", p_osd->scaling_config.AntiFlickerAlpha);
		fprintf(stdout,"Direction estimation      : %s\n", p_osd->scaling_config.AdaptativeEnable ? "enabled" : "disabled" );
		fprintf(stdout,"Alpha0                    : %ld\n", p_osd->alpha0);
		fprintf(stdout,"Alpha1                    : %ld\n", p_osd->alpha1);
		fprintf(stdout,"Fading                    : %s\n", p_osd->fading ? "enabled" : "disabled" );
		fprintf(stdout,"OSD output channel status : %s\n", p_osd->dcc_info.disp_info->osd_enable[0] ? "enabled" : "disabled" );
		if (p_osd->profile.ColorMode == EMhwlibColorMode_TrueColorWithKey)
			fprintf(stdout,"Key color (R/Cr,G/Y,B/Cb) : [%lu,%lu[, [%lu,%lu[, [%lu,%lu[\n", 
			        p_osd->kcolor.R_Cr, CROPV(end_r,256), 
				p_osd->kcolor.G_Y, CROPV(end_g,256),
				p_osd->kcolor.B_Cb, CROPV(end_b,256));
	}else{
		fprintf(stdout,"No persistent OSD buffer registered\n");
	}
}

/** Get the BPP corresponding to one mode:submode 
 * @param osd_color_mode
 * @param osd_color_format
 * @return bpp 0 on error
 */
RMuint32 get_osd_bpp(RMuint32 osd_color_mode, RMuint32 osd_color_format)
{
	switch(osd_color_mode){
		case EMhwlibColorMode_LUT_1BPP:
		case EMhwlibColorMode_LUT_2BPP:
		case EMhwlibColorMode_LUT_4BPP:
		case EMhwlibColorMode_LUT_8BPP:
			return (1 << (osd_color_mode - EMhwlibColorMode_LUT_1BPP));
		case EMhwlibColorMode_TrueColor:
		case EMhwlibColorMode_TrueColorWithKey:
			switch(osd_color_format){
				case EMhwlibColorFormat_16BPP_4444:
				case EMhwlibColorFormat_16BPP_565:
				case EMhwlibColorFormat_16BPP_1555:
					return 16;
				case EMhwlibColorFormat_24BPP:      //24BPP is really 32BPP
				case EMhwlibColorFormat_24BPP_565:  
				case EMhwlibColorFormat_32BPP:
				case EMhwlibColorFormat_32BPP_4444:
					return 32;
				default:
					return 0;
			}
		default:
			return 0;
	}
}

/** Get current OSD buffer info, store it in p_osd
 * @param p_osd - osd handle
 * @return RMstatus
 */
RMstatus get_osd_infos(struct osd_descriptor *p_osd)
{
	RMstatus status;
	RMuint32 surface;
	struct DisplayBlock_SurfaceSize_in_type size_in;
	struct DisplayBlock_SurfaceSize_out_type size_out;
	struct DisplayBlock_SurfaceInfo_out_type config;

	DEB(fprintf(stderr,"begin get_osd_infos\n"));
	if (p_osd == NULL || p_osd->dcc_info.pDCC == NULL || p_osd->dcc_info.pRUA == NULL)
		return RM_ERROR;

	status = DCCGetScalerModuleID(p_osd->dcc_info.pDCC, p_osd->dcc_info.route, DCCSurface_OSD, 0, 
	                              &p_osd->dcc_info.disp_info->osd_scaler[0]);
	if (RMFAILED(status)){
		fprintf(stderr,"Error getting OSD scaler\n");
		return status;
	}

	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_Surface,
	      &surface, sizeof(surface));
	DEB(fprintf(stderr,"surface = 0x%08lx, surf addr=%p\n",surface,&surface));
	if (surface == 0){
		p_osd->LumaAddr = 0;
		p_osd->LumaSize = 0;
		p_osd->ChromaAddr = 0;
		p_osd->ChromaSize = 0;
		return RM_OK;
	}
	
	RUAEP(p_osd->dcc_info.pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceInfo,
	      (void *) &surface, sizeof(void *), &config, sizeof(config));

	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0],RMGenericPropertyID_Enable,
	      &p_osd->dcc_info.disp_info->osd_enable[0], sizeof(p_osd->dcc_info.disp_info->osd_enable[0]));
			
	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0],RMDispOSDScalerPropertyID_ScalingConfig,
	      &p_osd->scaling_config, sizeof(p_osd->scaling_config));

	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0],RMGenericPropertyID_Alpha0,
	      &p_osd->alpha0, sizeof(p_osd->alpha0));

	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0],RMGenericPropertyID_Alpha1,
	      &p_osd->alpha1, sizeof(p_osd->alpha1));

	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0],RMGenericPropertyID_EnableFading,
	      &p_osd->fading, sizeof(p_osd->fading));

	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0],RMGenericPropertyID_KeyColor,
	      &p_osd->kcolor, sizeof(p_osd->kcolor));

	RUAGP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0],RMGenericPropertyID_ScalerInputWindow,
	      &p_osd->input_window, sizeof(p_osd->input_window));

	size_in.Width = config.Width;
	size_in.Height = config.Height;
	size_in.ColorMode = config.ColorMode;
	size_in.ColorFormat = config.ColorFormat;
	size_in.SamplingMode = config.SamplingMode;
	
	RUAEP(p_osd->dcc_info.pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceSize, &size_in,
	      sizeof(size_in), &size_out, sizeof(size_out));

	p_osd->LumaAddr = config.LumaAddress;
	p_osd->LumaSize = size_out.LumaSize;
	
	p_osd->ChromaAddr = config.ChromaAddress;
	p_osd->ChromaSize = size_out.ChromaSize;

	/* Copy at the right place */
	p_osd->bpp = get_osd_bpp(config.ColorMode, config.ColorFormat);
	p_osd->profile.SamplingMode = config.SamplingMode;
	p_osd->profile.ColorMode = config.ColorMode;
	p_osd->profile.ColorFormat = config.ColorFormat;
	p_osd->profile.Width = config.Width;
	p_osd->profile.Height = config.Height;
	p_osd->profile.ColorSpace = config.ColorSpace;

	DEB(fprintf(stderr,"end get_osd_infos\n"));
	return RM_OK;
}	

/** Create a new OSD Buffer
 * @param p_osd osd_descriptor of the buffer to create
 * @return RM_OK on success
 */
RMstatus create_osd_buf(struct osd_descriptor *p_osd)
{
	RMstatus status;
	RMbool persistent = TRUE;

	if (p_osd == NULL || p_osd->dcc_info.pRUA == NULL || p_osd->dcc_info.pDCC == NULL ){
		return RM_ERROR;
	}
	
	status = DCCOpenOSDVideoSource(p_osd->dcc_info.pDCC, &p_osd->profile, &p_osd->dcc_info.pOSDSource[0]);
	if (RMFAILED(status)){
		fprintf(stderr,"Error opening OSD video source\n");
		return status;
	}

	status = DCCGetScalerModuleID(p_osd->dcc_info.pDCC, p_osd->dcc_info.route, DCCSurface_OSD, 0, 
	                              &p_osd->dcc_info.disp_info->osd_scaler[0]);
	if (RMFAILED(status)){
		fprintf(stderr,"Error getting surface to display OSD source\n");
		return status;
	}

	status = DCCClearOSDVideoSource(p_osd->dcc_info.pOSDSource[0]);
	if (RMFAILED(status)){
		fprintf(stderr,"Error clearing OSD source\n");
		return status;
	}

	status = DCCSetSurfaceSource(p_osd->dcc_info.pDCC, p_osd->dcc_info.disp_info->osd_scaler[0], p_osd->dcc_info.pOSDSource[0]);
	if (RMFAILED(status)){
		fprintf(stderr,"Error setting OSD surface source\n");
		return status;
	}

	/* Set the buffer to be persistent */
	RUASP(p_osd->dcc_info.pRUA, p_osd->dcc_info.disp_info->osd_scaler[0], RMGenericPropertyID_PersistentSurface, &persistent, sizeof(persistent));

	return RM_OK;
}	

/** Enable/Disable an OSD mapping a graphic frame buffer
 * @param p_rua - rua handle
 * @param enable - enable or disable
 * @return RM_OK on success
 */
#if 1
RMstatus set_osdbuf_out_enable(struct RUA *p_rua, RMbool enable)
{
	RMstatus status = RM_OK;
	

	return status;
}
#endif

#if 0
/** Put an osd buffer on screen 
 * @param p_rua - rua handle
 * @param p_osd - osd to setup (format, size, start addreess, width and height should be setup)
 * @param standard - TV standard
 * @param output - TV outpout to use
 * @param mixer - mixer to use
 * @param scaler - scaler to use
 * @return RM_OK on success
 */
RMstatus init_display_osd(struct RUA *p_rua, struct osd_descriptor *p_osd, enum TVStandard standard, 
                          TV_Output output, RMuint32 mixer, RMuint32 scaler)
{
	RMstatus status = RM_OK;
	struct DispOSDScaler_SurfaceInputFormat_type osd_buffer;
	enum DispOSDScaler_Source_type src = DispOSDScaler_Source_Surface;
	RMuint32 target_x_pos, target_y_pos;
	RMuint32 x_size, y_size, target_x_size, target_y_size;
	RMbool interlaced;

	DEB(fprintf(stderr,"begin init_display_osd\n"));
	if (p_rua == NULL || p_osd == NULL)
		return RM_ERROR;

	get_video_size(p_rua, standard, &x_size, &y_size, &interlaced); 
	DEB(fprintf(stderr,"Standard %d => %ldx%ld, interlaced = %d\n",standard,x_size,y_size,interlaced));
	DEB(fprintf(stderr,"Target     => %ldx%ld\n",p_osd->width,p_osd->height));
	
	//osd_vpos = y_size - (interlaced ? 60 : 120);  // low end of screen
	target_x_size = p_osd->width;
	target_y_size = p_osd->height;
	if (interlaced) target_y_size /= 2;

	/* Scale picture down if too big for screen */
	if (target_x_size > x_size) {
		if (target_y_size * x_size / target_x_size > y_size) {
			target_x_size = target_x_size * y_size / target_y_size;
			target_y_size = y_size;
		} else {
			target_y_size = target_y_size * x_size / target_x_size;
			target_x_size = x_size;
		}
	} else if (target_y_size > y_size) {
		if (target_x_size * y_size / target_y_size > x_size) {
			target_y_size = target_y_size * x_size / target_x_size;
			target_x_size = x_size;
		} else {
			target_x_size = target_x_size * y_size / target_y_size;
			target_y_size = y_size;
		}
	}
	
	target_x_pos = (x_size - target_x_size) / 2;  // center
	target_y_pos = (y_size - target_y_size) / 2;
	DEB(fprintf(stderr,"scale : %ldx%ld\n",target_x_size,target_y_size));
	status = set_scaler(p_rua, standard, output, mixer, scaler, target_x_size, 
	                    target_y_size, ColorSpaceConversion_RGB_601);
	if (RMFAILED(status))
		fprintf(stderr,"Error setting scaler : %s\n",RMstatusToString(status));
	DEB(fprintf(stderr,"scaler : position %ldx%ld\n",target_x_pos,target_y_pos));
	move_scaler(p_rua, mixer, scaler, target_x_pos, target_y_pos);
	if (RMFAILED(status))
		fprintf(stderr,"Error setting move scaler : %s\n",RMstatusToString(status));


	osd_buffer.FormatMode = p_osd->format.FormatMode;
	osd_buffer.FormatSubmode = p_osd->format.FormatSubmode;
	osd_buffer.XSize = p_osd->width;
	osd_buffer.YSize = p_osd->height;
	osd_buffer.XPad = FALSE;
	osd_buffer.YPad = FALSE;
	osd_buffer.StartBuffer = p_osd->dram_address;
	osd_buffer.SizeBuffer = p_osd->size; //currently not used in EMhwlib

	DEB(fprintf(stderr,"OSD : %ldx%ld, starting at 0x%lx (%ld bytes)\n", osd_buffer.XSize, osd_buffer.YSize, 
	            osd_buffer.StartBuffer, osd_buffer.SizeBuffer));
	DEB(fprintf(stderr,"OSD : %s:%s (%ld:%ld) format\n", osd_color_mode_string[osd_buffer.FormatMode].name, 
	            osd_color_format_string[osd_buffer.FormatSubmode].name, osd_buffer.FormatMode, osd_buffer.FormatSubmode));

	/* pass bitmap buffer to hardware lib */
	status = RUASetProperty(p_rua, DispOSDScaler, RMDispOSDScalerPropertyID_Source, &src, sizeof(src), 0);
	if (RMFAILED(status)){
		fprintf(stderr,"  error setting RMDispOSDScalerPropertyID_Source\n");
		return RM_ERROR;
	}
	status = RUASetProperty(p_rua, DispOSDScaler, RMDispOSDScalerPropertyID_SurfaceInputFormat, 
			     &osd_buffer, sizeof(osd_buffer), 0);
	if (RMFAILED(status)) 
		fprintf(stderr,"Error %d setting property: DispOSDScalerProperty_Buffer\n", status);

	DEB(fprintf(stderr,"end init_display_osd\n"));
	return RM_OK;
}
#endif