spu.c

1. 8623L平台

	
	err = DCCOpenMultiplePictureOSDVideoSource(dcc_info.pDCC, &osdProfile, 2, &(mono_opt.pSPU_double_buffer_source), NULL);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot open OSD decoder %d\n", err);
		return err;
	}

	err = DCCGetOSDSurfaceInfo(dcc_info.pDCC, mono_opt.pSPU_double_buffer_source, NULL, &surface_addr, NULL);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot get surface address %d\n", err);
		return err;
	}

	err = DCCGetOSDPictureInfo(mono_opt.pSPU_double_buffer_source, 0, &(pic_addr[0]),  &(pic_luma_addr[0]), &(pic_luma_size[0]), NULL, NULL);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot get osd buffer info %d\n", err);
		return err;
	}


	err = DCCGetOSDPictureInfo(mono_opt.pSPU_double_buffer_source, 1, &(pic_addr[1]), &(pic_luma_addr[1]), &(pic_luma_size[1]), NULL, NULL);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot get osd buffer info %d\n", err);
		return err;
	}

	/* first pic (for double buffering) */
		
	buf_size = pic_luma_size[0];
	buf_addr = pic_luma_addr[0];

	err = RUALock(dcc_info.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(dcc_info.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;
	}
		
	memset(buf_map, 0x80, buf_size);


	doubleBuffer->buf0 = buf_map;
	doubleBuffer->buf0Size = buf_size;
	doubleBuffer->buf0Addr = buf_addr;
	doubleBuffer->isBuf0inUse = FALSE;
	doubleBuffer->buf0Cleared = FALSE;

	doubleBuffer->width = osdProfile.Width;
	doubleBuffer->height = osdProfile.Height;


	RUAUnMap(dcc_info.pRUA, buf_map, buf_size);
	err = RUAUnLock(dcc_info.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;
	}
	

	/* second pic */

	buf_size = pic_luma_size[1];
	buf_addr = pic_luma_addr[1];


	err = RUALock(dcc_info.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(dcc_info.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;
	}
		
	memset(buf_map, 0x90, buf_size);

	doubleBuffer->buf1 = buf_map;
	doubleBuffer->buf1Size = buf_size;
	doubleBuffer->buf1Addr = buf_addr;
	doubleBuffer->isBuf1inUse = FALSE;
	doubleBuffer->buf1Cleared = FALSE;


	RUAUnMap(dcc_info.pRUA, buf_map, buf_size);
	err = RUAUnLock(dcc_info.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;
	}

	


	RMDBGLOG((ENABLE, "bitmap size %lu, buf0 @0x%lx, buf1 @0x%lx\n", buf_size, doubleBuffer->buf0, doubleBuffer->buf1)); 


	/*possibly clean it before this with a fill */
		
	err = DCCSetSurfaceSource(dcc_info.pDCC, scaler, mono_opt.pSPU_double_buffer_source);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot set the surface source %d\n", err);
		return err;
	}
	err = DCCEnableVideoSource(mono_opt.pSPU_double_buffer_source, TRUE);
	if (RMFAILED(err)){
		fprintf(stderr,"Error enabling OSD buffer : %d\n",err);
		return err;
	}

	/* degrade the colors instead of xdownscaling */
	val = 512;
	while ((err = RUASetProperty(dcc_info.pRUA, scaler, RMGenericPropertyID_ColorDegradationBoundary,
				     &(val), sizeof(val), 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		RMDBGLOG((ENABLE, "Cannot set color degradation boundary %d\n", err));
		return err;
	}
		
	while ((err = RUASetProperty(dcc_info.pRUA, scaler, RMGenericPropertyID_Validate, NULL, 0, 0)) == RM_PENDING);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot validate scaler input window %d\n", err);
		return err;
	}

	//err = DCCInsertPictureInMultiplePictureOSDVideoSource(mono_opt.pSPU_double_buffer_source, 0);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot insert picture inside surface %d\n", err);
		return err;
	}


	return RM_OK;
}

RMstatus RMInitSPU(RMuint32 width, RMuint32 height)
{
	struct DCCOSDProfile osdProfile;
	RMstatus status = RM_OK;
	
	osdProfile.ColorSpace = EMhwlibColorSpace_YUV_601;
	osdProfile.SamplingMode = EMhwlibSamplingMode_444;
	osdProfile.ColorMode = EMhwlibColorMode_TrueColor; 
	osdProfile.ColorFormat = EMhwlibColorFormat_32BPP; /* unused */
	osdProfile.PixelAspectRatio.X = 1;
	osdProfile.PixelAspectRatio.Y = 1;
	
	osdProfile.Width = width; // should be the dimensions from the track, but they are wrong, so we hard code
	osdProfile.Height = height;
	
	RMDBGLOG((ENABLE, "RMinitSPU(%lu x %lu)\n", width, height));

	if (mono_opt.pSPU_double_buffer_source) {
		RMDBGLOG((ENABLE, "doubleBuffer already exists\n"));
		if ((mono_opt.doubleBuffer.width != width) ||
		    (mono_opt.doubleBuffer.height != height)) {
			RMDBGLOG((ENABLE, "size dont match, destroy and recreate\n"));
			status = RMCloseSPU();
			if (status != RM_OK)
				return status;
		}
		else
			return RM_OK;
	}
			
		

	/* Init SPU DoubleBuffer OSD */
	status = RMInitDoubleBufferOSD(NULL, osdProfile, &(mono_opt.doubleBuffer));
	if (status != RM_OK) {
		fprintf(stderr, "cant init doubleBufferOSD\n");
		if (mono_opt.pSPU_double_buffer_source) {
			RMDBGLOG((ENABLE, "close doubleBufferOSD\n"));
			status = DCCCloseVideoSource(mono_opt.pSPU_double_buffer_source);
			mono_opt.pSPU_double_buffer_source = NULL;
			if (RMFAILED(status)) {
				RMDBGLOG((ENABLE, "Cannot close SPU doubleBuffer source %d\n", status));
				return status;
			}
		}
		return RM_ERROR;
	}
	return RM_OK;
}

RMstatus RMCloseSPU(void)
{
	if (mono_opt.pSPU_double_buffer_source) {
		RMstatus status;
		RMDBGLOG((ENABLE, "close doubleBufferOSD\n"));
		status = DCCCloseVideoSource(mono_opt.pSPU_double_buffer_source);
		mono_opt.pSPU_double_buffer_source = NULL;
		if (RMFAILED(status)) {
			RMDBGLOG((ENABLE, "Cannot close SPU doubleBuffer source %d\n", status));
			return status;
		}
	}
	return RM_OK;
}



RMstatus RMBlendSPU(RMuint8 *buffer)
{
	RMstatus err;
	RMuint8 *buf_map;
	RMuint32 buf_size, buf_addr;
	RMuint32 blendPic = 0;

	if (!mono_opt.pSPU_double_buffer_source)
		return RM_ERROR;

	if (!mono_opt.doubleBuffer.isBuf0inUse) {
		//blend buf0: copy *buffer into doublebufffer and activate it

		RMDBGLOG((ENABLE, "blending buf0\n"));

		buf_size = mono_opt.doubleBuffer.buf0Size;
		buf_addr = mono_opt.doubleBuffer.buf0Addr;
		mono_opt.doubleBuffer.isBuf0inUse = TRUE;
		mono_opt.doubleBuffer.buf0Cleared = FALSE;
		blendPic = 0;
		mono_opt.doubleBuffer.isBuf1inUse = FALSE;

	} else if (!mono_opt.doubleBuffer.isBuf1inUse) {
		RMDBGLOG((ENABLE, "blending buf1\n"));

		buf_size = mono_opt.doubleBuffer.buf1Size;
		buf_addr = mono_opt.doubleBuffer.buf1Addr;
		mono_opt.doubleBuffer.isBuf1inUse = TRUE;
		mono_opt.doubleBuffer.buf1Cleared = FALSE;
		blendPic = 1;
		mono_opt.doubleBuffer.isBuf0inUse = FALSE;
	}
	else
		return RM_ERROR;
		

	err = RUALock(dcc_info.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(dcc_info.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;
	}
	

	// reorder Y,V,U,A planes into UYVA,UYVA,... pixels
	{
		RMuint32 bitmap_size = mono_opt.doubleBuffer.width * mono_opt.doubleBuffer.height;
		RMuint8 *buf_Y = buffer;
		RMuint8 *buf_V = buf_Y + (bitmap_size);
		RMuint8 *buf_U = buf_V + (bitmap_size);
		RMuint8 *buf_A = buf_U + (bitmap_size);
		RMuint32 i = 0;

		while (i < (bitmap_size*4)) {
			*(buf_map+i) = *buf_U++;    // bleu
			*(buf_map+i+1) = *buf_Y++;  
			*(buf_map+i+2) = *buf_V++;  // rouge?

			// alpha values are in the [0,16] range, convert them to [0,255]
			if (*buf_A) 
				*(buf_map+i+3) = RMmin(*buf_A * 16, 255);
			else
				*(buf_map+i+3) = 0;
			buf_A++;

			i+=4;
		}
	}
	

	RUAUnMap(dcc_info.pRUA, buf_map, buf_size);
	err = RUAUnLock(dcc_info.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;
	}
	
	err = DCCInsertPictureInMultiplePictureOSDVideoSource(mono_opt.pSPU_double_buffer_source, blendPic, 0);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot insert picture inside surface %d\n", err);
		return err;
	}
	
	return RM_OK;
}

RMstatus RMClearSPU()
{
	RMstatus err;
	RMuint8 *buf_map;
	RMuint32 buf_size, buf_addr;
	RMuint32 blendPic = 0;

	if (!mono_opt.pSPU_double_buffer_source)
		return RM_ERROR;

	if (mono_opt.doubleBuffer.buf0Cleared)
		return RM_OK;

	RMDBGLOG((ENABLE, "clearSPU\n"));
	buf_size = mono_opt.doubleBuffer.buf0Size;
	buf_addr = mono_opt.doubleBuffer.buf0Addr;
	mono_opt.doubleBuffer.isBuf0inUse = FALSE;
	mono_opt.doubleBuffer.buf0Cleared = TRUE;
	blendPic = 0;
	mono_opt.doubleBuffer.isBuf1inUse = FALSE;

	err = RUALock(dcc_info.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(dcc_info.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;
	}
	

	// clear buffer
	memset(buf_map, 0, buf_size);
	

	RUAUnMap(dcc_info.pRUA, buf_map, buf_size);
	err = RUAUnLock(dcc_info.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;
	}
	
	err = DCCInsertPictureInMultiplePictureOSDVideoSource(mono_opt.pSPU_double_buffer_source, blendPic, 0);
	if (RMFAILED(err)) {
		fprintf(stderr, "Cannot insert picture inside surface %d\n", err);
		return err;
	}
	
	return RM_OK;
}


#if 0
static inline RMstatus init_doubleBuffer_OSD(void)
{
	struct DCCOSDProfile osdProfile;
	RMstatus status = RM_OK;
	
	osdProfile.ColorSpace = EMhwlibColorSpace_YUV_601;
	osdProfile.SamplingMode = EMhwlibSamplingMode_444;
	osdProfile.ColorMode = EMhwlibColorMode_TrueColor; 
	osdProfile.ColorFormat = EMhwlibColorFormat_32BPP; /* unused */
	osdProfile.PixelAspectRatio.X = 1;
	osdProfile.PixelAspectRatio.Y = 1;
	
	osdProfile.Width = 720; // should be the dimensions from the track, but they are wrong, so we hard code
	osdProfile.Height = 576;
	
	/* Init SPU DoubleBuffer OSD */
	status = RMInitDoubleBufferOSD(NULL, osdProfile, &(mono_opt.doubleBuffer));
	if (status != RM_OK) {
		fprintf(stderr, "cant init doubleBufferOSD\n");
		if (mono_opt.pSPU_double_buffer_source) {
			RMDBGLOG((ENABLE, "close doubleBufferOSD\n"));
			status = DCCCloseVideoSource(mono_opt.pSPU_double_buffer_source);
			mono_opt.pSPU_double_buffer_source = NULL;
			if (RMFAILED(status)) {
				RMDBGLOG((ENABLE, "Cannot close SPU doubleBuffer source %d\n", status));
				return status;
			}
		}
		return status;
	}
	return RM_OK;
}
#endif






/* END SPU implementation */