dcc_osd.c

dcc code for smp 8634 media processor

		(*ppVideoSource)->pictures[i].UV_size = valueIn.ChromaSize;
		(*ppVideoSource)->pictures[i].P_size = valueIn.PaletteSize;
		(*ppVideoSource)->pictures[i].P_addr = valueOut.PaletteAddress;
		(*ppVideoSource)->pictures[i].width = dram_in.Width;
		(*ppVideoSource)->pictures[i].height = dram_in.Height;

	}
	gfxInteraction.Surface = surface_init.Address;
	gfxInteraction.Enable = TRUE;
 	err = RUASetProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_EnableGFXInteraction,
			     &gfxInteraction, sizeof(gfxInteraction), 0);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Error Cannot enable GFX Interaction on Surface %s\n", RMstatusToString(err)));
		pDCC->rua_free(pDCC->pRUA, surface_init.Address);
		return err;
	}



	return RM_OK;
}

RMstatus DCCGetOSDPictureInfo(struct DCCVideoSource *pVideoSource, RMuint32 index, RMuint32 *PictureAddr,  RMuint32 *LumaAddr, RMuint32 *LumaSize, RMuint32 *ChromaAddr, RMuint32 *ChromaSize)
{
	RMASSERT(pVideoSource);
	RMASSERT(pVideoSource->pictures);

	if(index >= pVideoSource->picture_count)
		return RM_ERROR;

	if(PictureAddr != NULL)
		*PictureAddr = pVideoSource->pictures[index].picture_addr;
	if(LumaAddr != NULL)
		*LumaAddr = pVideoSource->pictures[index].Y_addr;
	if(LumaSize != NULL)
		*LumaSize = pVideoSource->pictures[index].Y_size;
	if(ChromaAddr != NULL)
		*ChromaAddr = pVideoSource->pictures[index].UV_addr;
	if(ChromaSize != NULL)
		*ChromaSize = pVideoSource->pictures[index].UV_size;
				     
	return RM_OK;
}

RMstatus DCCGetOSDVideoSourceInfo(struct DCCVideoSource *pVideoSource, RMuint32 *LumaAddr, RMuint32 *LumaSize, RMuint32 *ChromaAddr, RMuint32 *ChromaSize)
{
	return DCCGetOSDPictureInfo(pVideoSource, 0 , NULL, LumaAddr, LumaSize, ChromaAddr, ChromaSize);
}

RMstatus DCCGetOSDSurfaceInfo(struct DCC *pDCC, struct DCCVideoSource *pVideoSource, struct DCCOSDProfile *profile, 
			      RMuint32 *SurfaceAddr, RMuint32 *SurfaceSize)
{
      if(profile != NULL) {
	      struct DisplayBlock_SurfaceSize_in_type dram_in;
	      struct DisplayBlock_SurfaceSize_out_type dram_out;
	      RMstatus err;
	      dram_in.ColorMode = profile->ColorMode;
	      dram_in.ColorFormat = profile->ColorFormat;
	      dram_in.SamplingMode = profile->SamplingMode;
	      dram_in.Width = profile->Width;
	      dram_in.Height = profile->Height;
	      err = RUAExchangeProperty(pDCC->pRUA, DisplayBlock, RMDisplayBlockPropertyID_SurfaceSize, 
					&dram_in, sizeof(dram_in), &dram_out, sizeof(dram_out));
	      if (RMFAILED(err)) {
		      RMDBGLOG((ENABLE, "Error Cannot get size to allocate the OSD surface %d\n", err));
		      return err;
	      }
	      *SurfaceSize = dram_out.BufferSize;

      }

      *SurfaceAddr = pVideoSource->surface;
      return RM_OK;
}
 

static RMstatus set_memory(struct RUA *pRUA, 
			   RMuint32 rua_addr, 
			   RMuint32 size, 
			   RMuint8 * user_addr, 
			   RMbool clear,
			   RMint32 clearwith)
{
	RMuint32 chunk;
	RMuint8 *BaseAddr;
	RMstatus err;

#if ((EM86XX_MODE == EM86XX_MODEID_WITHHOST) || (EM86XX_CHIP == EM86XX_CHIPID_TANGO2))
	while (size) {
		chunk = RMmin(size, 0x100000);  // 1 MByte max
		
		err = RUALock(pRUA, rua_addr, chunk);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Error locking OSD buffer at 0x%08lX (0x%08lX bytes): %s\n", rua_addr, chunk, RMstatusToString(err)));
			return err;
		}
		BaseAddr = RUAMap(pRUA, rua_addr, chunk);
		if (BaseAddr == NULL) {
			RMDBGLOG((ENABLE, "Error mapping OSD buffer at 0x%08lX (0x%08lX bytes)\n", rua_addr, chunk));
			return RM_ERROR;
		}
		
		if((!clear) && (user_addr != NULL))
			RMMemcpy(BaseAddr, user_addr, chunk);
		else
			RMMemset(BaseAddr, clearwith, chunk);
		
		RUAUnMap(pRUA, BaseAddr, chunk);

		err = RUAUnLock(pRUA, rua_addr, chunk);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Error unlocking OSD buffer at 0x%08lX (0x%08lX bytes): %s\n", rua_addr, chunk, RMstatusToString(err)));
			return err;
		}
		rua_addr += chunk;
		size -= chunk;
		if((!clear) && (user_addr != NULL)) user_addr += chunk;
	}
#else
	BaseAddr = (RMuint8 *)rua_addr;
	chunk = 0;
	err = RM_OK;
	if((!clear) && (user_addr != NULL))
		RMMemcpy(BaseAddr, user_addr, size);
	else
		RMMemset(BaseAddr, clearwith, size);
#endif
	return RM_OK;
}

RMstatus DCCClearOSDVideoSource(struct DCCVideoSource *pVideoSource)
{
	return DCCClearOSDPicture(pVideoSource, 0);
}

RMstatus DCCClearOSDPicture(struct DCCVideoSource *pVideoSource, RMuint32 index)
{
	RMuint32 Y_addr, Y_size, UV_addr, UV_size;
	RMstatus err;

	err = DCCGetOSDPictureInfo(pVideoSource, index, NULL, &Y_addr, &Y_size, &UV_addr, &UV_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get OSD video info, %s\n", RMstatusToString(err)));
		return err;
	}

	err = set_memory(pVideoSource->pRUA, Y_addr, Y_size, (RMuint8 *)NULL, TRUE, 0);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot clear memory of Luma Buffer 0x%08lx 0x%08lx, %s\n", Y_addr, Y_size, RMstatusToString(err)));
		return err;
	}

	if ((UV_addr != 0) && (UV_size > 0)) {
		err = set_memory(pVideoSource->pRUA, UV_addr, UV_size, (RMuint8 *)NULL, TRUE, 128);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot clear memory of Chroma Buffer 0x%08lx 0x%08lx, %s\n", UV_addr, UV_size, RMstatusToString(err)));
			return err;
		}
	}

	return RM_OK;
}

RMstatus DCCSetOSDVideoSource(struct DCCVideoSource *pVideoSource, RMuint8 * pUserLuma, RMuint8 * pUserChroma)
{
	return DCCSetOSDPicture(pVideoSource, 0, pUserLuma, pUserChroma);
}

RMstatus DCCSetOSDPicture(struct DCCVideoSource *pVideoSource, RMuint32 index, RMuint8 * pUserLuma, RMuint8 * pUserChroma)
{
	RMuint32 Y_addr, Y_size, UV_addr, UV_size;
	RMstatus err;

	err = DCCGetOSDPictureInfo(pVideoSource, index, NULL, &Y_addr, &Y_size, &UV_addr, &UV_size);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot get OSD video info, %s\n", RMstatusToString(err)));
		return err;
	}
	
	err = set_memory(pVideoSource->pRUA, Y_addr, Y_size, pUserLuma, FALSE, 0);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set memory of Luma Buffer 0x%08lx 0x%08lx, %s\n", Y_addr, Y_size, RMstatusToString(err)));
		return err;
	}
	
	if ((UV_addr != 0) && (UV_size > 0)) {
		err = set_memory(pVideoSource->pRUA, UV_addr, UV_size, pUserChroma, FALSE, 0);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Cannot set memory of Chroma Buffer 0x%08lx 0x%08lx, %s\n", UV_addr, UV_size, RMstatusToString(err)));
			return err;
		}
	}

	return RM_OK;
}

RMstatus DCCInsertPictureInMultiplePictureOSDVideoSource(struct DCCVideoSource *pVideoSource, RMuint32 index, RMuint64 Pts)
{
	RMstatus err;
	struct DisplayBlock_InsertPictureInSurfaceFifo_type param;

	RMASSERT(pVideoSource);
	RMASSERT(pVideoSource->pictures);


	param.Surface = pVideoSource->surface;
	param.Picture = pVideoSource->pictures[index].picture_addr;
	param.Pts = Pts;
	err = RUASetProperty(pVideoSource->pRUA, DisplayBlock, RMDisplayBlockPropertyID_InsertPictureInSurfaceFifo, &param, sizeof(param), 0);
	if (RMFAILED(err)){
		RMDBGLOG((ENABLE, "Cannot insert picture into surface, %s\n", RMstatusToString(err)));
		return err;
	}
	
	return err;
}