Merge pull request #312 from raven02/patch-10

cellResc : add those unimplemented and error logging

rpcs3/Emu/GS/GCM.h

@@ -24,13 +24,13 @@ enum
 
 enum
 {
-	CELL_GCM_VERTEX_S1 	= 1,
+	CELL_GCM_VERTEX_S1      = 1,
-	CELL_GCM_VERTEX_F 	= 2,
+	CELL_GCM_VERTEX_F       = 2,
-	CELL_GCM_VERTEX_S	= 3,
+	CELL_GCM_VERTEX_S       = 3,
-	CELL_GCM_VERTEX_UB 	= 4,
+	CELL_GCM_VERTEX_UB      = 4,
-	CELL_GCM_VERTEX_S32K 	= 5,
+	CELL_GCM_VERTEX_S32K    = 5,
-	CELL_GCM_VERTEX_CMP 	= 6,
+	CELL_GCM_VERTEX_CMP     = 6,
-	CELL_GCM_VERTEX_UB256 	= 7,
+	CELL_GCM_VERTEX_UB256   = 7,
 };
 
 enum
@@ -72,34 +72,43 @@ enum
 	CELL_GCM_TEXTURE_COMPRESSED_R8B8_R8G8   = 0xAE,
 
 	// Swizzle Flag
-	CELL_GCM_TEXTURE_SZ  = 0x00,
+	CELL_GCM_TEXTURE_SZ = 0x00,
-	CELL_GCM_TEXTURE_LN  = 0x20,
+	CELL_GCM_TEXTURE_LN = 0x20,
 	
 	// Normalization Flag
-	CELL_GCM_TEXTURE_NR  = 0x00,
+	CELL_GCM_TEXTURE_NR = 0x00,
-	CELL_GCM_TEXTURE_UN  = 0x40,
+	CELL_GCM_TEXTURE_UN = 0x40,
 };
 
 // GCM Surface
 enum
 {
-	// Target
+	// Surface Target
-	CELL_GCM_SURFACE_TARGET_NONE    = 0,
+	CELL_GCM_SURFACE_TARGET_NONE   = 0,
-	CELL_GCM_SURFACE_TARGET_0       = 1,
+	CELL_GCM_SURFACE_TARGET_0      = 1,
-	CELL_GCM_SURFACE_TARGET_1       = 2,
+	CELL_GCM_SURFACE_TARGET_1      = 2,
-	CELL_GCM_SURFACE_TARGET_MRT1    = 0x13,
+	CELL_GCM_SURFACE_TARGET_MRT1   = 0x13,
-	CELL_GCM_SURFACE_TARGET_MRT2    = 0x17,
+	CELL_GCM_SURFACE_TARGET_MRT2   = 0x17,
-	CELL_GCM_SURFACE_TARGET_MRT3    = 0x1f,
+	CELL_GCM_SURFACE_TARGET_MRT3   = 0x1f,
+
+	// Surface Depth
+	CELL_GCM_SURFACE_Z16    = 1,
+	CELL_GCM_SURFACE_Z24S8  = 2,
+
+	// Surface Antialias
+	CELL_GCM_SURFACE_CENTER_1            = 2,
+	CELL_GCM_SURFACE_DIAGONAL_CENTERED_2 = 3,
+	CELL_GCM_SURFACE_SQUARE_CENTERED_4   = 4,
+	CELL_GCM_SURFACE_SQUARE_ROTATED_4    = 5,
+
+	// Surface type
+	CELL_GCM_SURFACE_PITCH    = 1,
+	CELL_GCM_SURFACE_SWIZZLE  = 2,
+
+	// Surface format
+	CELL_GCM_SURFACE_A8R8G8B8       = 8,
+	CELL_GCM_SURFACE_F_W16Z16Y16X16 = 11,
 
-	// Depth
-	CELL_GCM_SURFACE_Z16            = 1,
-	CELL_GCM_SURFACE_Z24S8          = 2,
-	
-	// Antialias
-	CELL_GCM_SURFACE_CENTER_1		= 2,
-	CELL_GCM_SURFACE_DIAGONAL_CENTERED_2 	= 3,
-	CELL_GCM_SURFACE_SQUARE_CENTERED_4	= 4,
-	CELL_GCM_SURFACE_SQUARE_ROTATED_4	= 5,
 };
 
 // GCM Reports

rpcs3/Emu/SysCalls/Modules/cellResc.cpp

@@ -271,19 +271,19 @@ u8 GcmSurfaceFormat2GcmTextureFormat(u8 surfaceFormat, u8 surfaceType)
 {
 	u8 result = 0;
 
-	switch(surfaceFormat){
+	switch (surfaceFormat){
-	case 8:	 result = 0x85; break; //case CELL_GCM_SURFACE_A8R8G8B8:	      result = CELL_GCM_TEXTURE_A8R8G8B8;	            break;
+	case CELL_GCM_SURFACE_A8R8G8B8:		result = CELL_GCM_TEXTURE_A8R8G8B8;			break;
-	case 11: result = 0x9A;	break; //case CELL_GCM_SURFACE_F_W16Z16Y16X16:    result = CELL_GCM_TEXTURE_W16_Z16_Y16_X16_FLOAT;	break;
+	case CELL_GCM_SURFACE_F_W16Z16Y16X16:	result = CELL_GCM_TEXTURE_W16_Z16_Y16_X16_FLOAT;	break;
 	default: return 0xFF; //Error
 	}
 
-	switch(surfaceType){
+	switch (surfaceType){
-	case 1: result |= 0x20; break; //case CELL_GCM_SURFACE_PITCH:   result |= CELL_GCM_TEXTURE_LN; break; 
+	case CELL_GCM_SURFACE_PITCH:   result |= CELL_GCM_TEXTURE_LN; break;
-	case 2: result |= 0x00; break; //case CELL_GCM_SURFACE_SWIZZLE: result |= CELL_GCM_TEXTURE_SZ; break;
+	case CELL_GCM_SURFACE_SWIZZLE: result |= CELL_GCM_TEXTURE_SZ; break;
 	default: return 0xFF; //Error
 	}
 
-	result |= 0x00; //result |= CELL_GCM_TEXTURE_NR
+	result |= CELL_GCM_TEXTURE_NR;
 	return result;
 }
 
@@ -418,10 +418,16 @@ int cellRescInit(mem_ptr_t<CellRescInitConfig> initConfig)
 {
 	cellResc.Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.GetAddr());
 
-	if(s_rescInternalInstance->m_bInitialized)
+	if (s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescInit : CELL_RESC_ERROR_REINITIALIZED");
 		return CELL_RESC_ERROR_REINITIALIZED;
-	if(!initConfig.IsGood() || InternalVersion(initConfig.GetAddr()) == -1 || !CheckInitConfig(initConfig))
+	}
+	if (!initConfig.IsGood() || InternalVersion(initConfig.GetAddr()) == -1 || !CheckInitConfig(initConfig))
+	{
+		cellResc.Error("cellRescInit : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	InitMembers();
 	s_rescInternalInstance->m_initConfig = *initConfig; // TODO: This may be incompatible with older binaries
@@ -432,8 +438,13 @@ int cellRescInit(mem_ptr_t<CellRescInitConfig> initConfig)
 
 void cellRescExit()
 {
+	cellResc.Warning("cellRescExit()");
+
 	if(!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescExit()");
 		return;
+	}
 
 	// TODO: ?
 
@@ -442,11 +453,13 @@ void cellRescExit()
 
 int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, mem32_t bufferMode)
 {
-	cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)",
+	cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.GetAddr());
-		resolutionId, bufferMode.GetAddr());
 
 	if (!bufferMode.IsGood())
+	{
+		cellResc.Error("cellRescVideoOutResolutionId2RescBufferMode : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	switch (resolutionId)
 	{
@@ -454,7 +467,9 @@ int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, mem32_t buffer
 	case CELL_VIDEO_OUT_RESOLUTION_720:  bufferMode = CELL_RESC_1280x720;  break;
 	case CELL_VIDEO_OUT_RESOLUTION_480:  bufferMode = CELL_RESC_720x480;   break;
 	case CELL_VIDEO_OUT_RESOLUTION_576:  bufferMode = CELL_RESC_720x576;   break;
-	default: return CELL_RESC_ERROR_BAD_ARGUMENT;
+	default: 
+		cellResc.Error("cellRescVideoOutResolutionId2RescBufferMod : CELL_RESC_ERROR_BAD_ARGUMENT");
+		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
 	return CELL_OK;
@@ -464,14 +479,24 @@ int cellRescSetDsts(u32 dstsMode, mem_ptr_t<CellRescDsts> dsts)
 {
 	cellResc.Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.GetAddr());
 
-	if(!s_rescInternalInstance->m_bInitialized)
+	if (!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescSetDst : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
-	if (!dsts.IsGood())
+	}
-		return CELL_RESC_ERROR_BAD_ARGUMENT;
 
-	if((dstsMode != CELL_RESC_720x480)  && (dstsMode != CELL_RESC_720x576) && 
+	if (!dsts.IsGood())
-	   (dstsMode != CELL_RESC_1280x720) && (dstsMode != CELL_RESC_1920x1080))
+	{
+		cellResc.Error("cellRescSetDst : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
+
+	if ((dstsMode != CELL_RESC_720x480) && (dstsMode != CELL_RESC_720x576) &&
+		(dstsMode != CELL_RESC_1280x720) && (dstsMode != CELL_RESC_1920x1080))
+	{
+		cellResc.Error("cellRescSetDsts : CELL_RESC_ERROR_BAD_ARGUMENT");
+		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	s_rescInternalInstance->m_rescDsts[GetRescDestsIndex(dstsMode)] = *dsts;
 
@@ -482,21 +507,38 @@ int cellRescSetDisplayMode(u32 displayMode)
 {
 	cellResc.Warning("cellRescSetDisplayMode(displayMode=%d)", displayMode);
 
-	if(!s_rescInternalInstance->m_bInitialized)
+	if (!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
-	if(!(s_rescInternalInstance->m_initConfig.supportModes & displayMode))
+	}
-		return CELL_RESC_ERROR_BAD_ARGUMENT;
 
-	if((displayMode != CELL_RESC_720x480)  && (displayMode != CELL_RESC_720x576) && 
+	if (!(s_rescInternalInstance->m_initConfig.supportModes & displayMode))
-	   (displayMode != CELL_RESC_1280x720) && (displayMode != CELL_RESC_1920x1080))
+	{
+		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
+
+	if ((displayMode != CELL_RESC_720x480) && (displayMode != CELL_RESC_720x576) &&
+		(displayMode != CELL_RESC_1280x720) && (displayMode != CELL_RESC_1920x1080))
+	{
+		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
+		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	s_rescInternalInstance->m_dstMode = displayMode;
 
-	if((IsPalInterpolate() || IsPalDrop()) && s_rescInternalInstance->m_initConfig.flipMode==CELL_RESC_DISPLAY_HSYNC)
+	if ((IsPalInterpolate() || IsPalDrop()) && s_rescInternalInstance->m_initConfig.flipMode == CELL_RESC_DISPLAY_HSYNC)
+	{
+		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
 		return CELL_RESC_ERROR_BAD_COMBINATION;
+	}
+
 	if(IsPal60Hsync() && s_rescInternalInstance->m_initConfig.flipMode==CELL_RESC_DISPLAY_VSYNC)
+	{
+		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
 		return CELL_RESC_ERROR_BAD_COMBINATION;
+	}
 
 	s_rescInternalInstance->m_pRescDsts = &s_rescInternalInstance->m_rescDsts[GetRescDestsIndex(displayMode)];
 	GetScreenSize(s_rescInternalInstance->m_dstMode, &(s_rescInternalInstance->m_dstWidth),	&(s_rescInternalInstance->m_dstHeight));
@@ -556,9 +598,16 @@ int cellRescAdjustAspectRatio(float horizontal, float vertical)
 	cellResc.Warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical);
 
 	if(!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
+	}
+
 	if((horizontal < 0.5f || 2.f < horizontal) || (vertical < 0.5f || 2.f < vertical))
+	{
+		cellResc.Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	s_rescInternalInstance->m_ratioAdjX = horizontal;
 	s_rescInternalInstance->m_ratioAdjY = vertical;
@@ -579,9 +628,16 @@ int cellRescSetPalInterpolateDropFlexRatio(float ratio)
 	cellResc.Warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio);
 
 	if(!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
+	}
+
 	if(ratio < 0.f || 1.f < ratio)
+	{
+		cellResc.Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	s_rescInternalInstance->m_flexRatio = ratio;
 
@@ -590,11 +646,13 @@ int cellRescSetPalInterpolateDropFlexRatio(float ratio)
 
 int cellRescGetBufferSize(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fragmentShader)
 {
-	cellResc.Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)",
+	cellResc.Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
-		colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
 
-	if(!s_rescInternalInstance->m_bInitialized)
+	if (!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescGetBufferSize : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
+	}
 
 	s32 colorBuffersSize, vertexArraySize, fragmentUcodeSize;
 	if (s_rescInternalInstance->m_initConfig.resourcePolicy & CELL_RESC_MINIMUM_VRAM)
@@ -622,8 +680,11 @@ int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
 {
 	cellResc.Log("cellRescGetNumColorBuffers(dstMode=%d, palTemporalMode=%d, reserved=%d)", dstMode, palTemporalMode, reserved);
 
-	if(reserved != 0)
+	if (reserved != 0)
+	{
+		cellResc.Error("cellRescGetNumColorBuffers : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	return dstMode==CELL_RESC_720x576
 		? ((palTemporalMode==CELL_RESC_PAL_60_INTERPOLATE || 
@@ -638,11 +699,13 @@ int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
 
 int cellRescGcmSurface2RescSrc(mem_ptr_t<CellGcmSurface> gcmSurface, mem_ptr_t<CellRescSrc> rescSrc)
 {
-	cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)",
+	cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.GetAddr(), rescSrc.GetAddr());
-		gcmSurface.GetAddr(), rescSrc.GetAddr());
 
 	if(!gcmSurface.IsGood() || !rescSrc.IsGood())
+	{
+		cellResc.Error("cellRescGcmSurface2RescSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	u8 textureFormat = GcmSurfaceFormat2GcmTextureFormat(gcmSurface->color_format, gcmSurface->type);
 
@@ -669,11 +732,23 @@ int cellRescSetSrc(s32 idx, mem_ptr_t<CellRescSrc> src)
 	cellResc.Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.GetAddr());
 
 	if(!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
+	}
+
 	if(idx < 0 || SRC_BUFFER_NUM <= idx || !src.IsGood())
+	{
+		cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
+
 	if(src->width < 1 || 4096 < src->width || src->height < 1 || 4096 < src->height)
+	{
+		cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
+
 
 	cellResc.Log(" *** format=0x%x", src->format.ToLE());
 	cellResc.Log(" *** pitch=%d", src->pitch.ToLE());
@@ -695,9 +770,17 @@ int cellRescSetConvertAndFlip(mem_ptr_t<CellGcmContextData> cntxt, s32 idx)
 	cellResc.Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.GetAddr(), idx);
 
 	if(!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
+	}
+
 	if(idx < 0 || SRC_BUFFER_NUM <= idx)
+	{
+		cellResc.Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
+
 
 	if(!IsTextureNR())
 		BuildupVertexBufferUN(idx);
@@ -722,17 +805,27 @@ int cellRescSetWaitFlip()
 
 int cellRescSetBufferAddress(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fragmentShader)
 {
-	cellResc.Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)",
+	cellResc.Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
-		colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
 
 	if(!s_rescInternalInstance->m_bInitialized)
+	{
+		cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
+	}
+
 	if(!colorBuffers.IsGood() || !vertexArray.IsGood() || !fragmentShader.IsGood()) 
+	{
+		cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
+
 	if(colorBuffers.GetAddr() % COLOR_BUFFER_ALIGNMENT ||
 		vertexArray.GetAddr() % VERTEX_BUFFER_ALIGNMENT ||
 		fragmentShader.GetAddr() % FRAGMENT_SHADER_ALIGNMENT)
-		return CELL_RESC_ERROR_BAD_ALIGNMENT;
+	{
+		cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ARGUMENT");
+		return CELL_RESC_ERROR_BAD_ARGUMENT;
+	}
 
 	s_rescInternalInstance->m_colorBuffersEA_addr  = colorBuffers.GetAddr();
 	s_rescInternalInstance->m_vertexArrayEA_addr   = vertexArray.GetAddr();
@@ -764,8 +857,11 @@ int cellRescSetFlipHandler(u32 handler_addr)
 {
 	cellResc.Warning("cellRescSetFlipHandler(handler_addr=0x%x)", handler_addr);
 
-	if(handler_addr != 0 && !Memory.IsGoodAddr(handler_addr))
+	if (handler_addr != 0 && !Memory.IsGoodAddr(handler_addr))
+	{
+		cellResc.Error("cellRescSetFlipHandler : CELL_EFAULT");
 		return CELL_EFAULT;
+	}
 
 	Emu.GetGSManager().GetRender().m_flip_handler.SetAddr(handler_addr);
 
@@ -786,6 +882,37 @@ int cellRescGetFlipStatus()
 	return Emu.GetGSManager().GetRender().m_flip_status;
 }
 
+int cellRescGetRegisterCount()
+{
+	UNIMPLEMENTED_FUNC(cellResc);
+	return CELL_OK;
+}
+
+int cellRescGetLastFlipTime()
+{
+	UNIMPLEMENTED_FUNC(cellResc);
+	return CELL_OK;
+}
+
+int cellRescSetRegisterCount()
+{
+	UNIMPLEMENTED_FUNC(cellResc);
+	return CELL_OK;
+}
+
+int cellRescSetVBlankHandler()
+{
+	UNIMPLEMENTED_FUNC(cellResc);
+	return CELL_OK;
+}
+
+int cellRescCreateInterlaceTable()
+{
+	UNIMPLEMENTED_FUNC(cellResc);
+	return CELL_OK;
+}
+
+
 void cellResc_init()
 {
 	cellResc.AddFunc(0x25c107e6, cellRescSetConvertAndFlip);
@@ -796,20 +923,20 @@ void cellResc_init()
 	cellResc.AddFunc(0x10db5b1a, cellRescSetDsts);
 	cellResc.AddFunc(0x129922a0, cellRescResetFlipStatus);
 	cellResc.AddFunc(0x19a2a967, cellRescSetPalInterpolateDropFlexRatio);
-	//cellResc.AddFunc(0x1dd3c4cd, cellRescGetRegisterCount);
+	cellResc.AddFunc(0x1dd3c4cd, cellRescGetRegisterCount);
 	cellResc.AddFunc(0x22ae06d8, cellRescAdjustAspectRatio);
 	cellResc.AddFunc(0x23134710, cellRescSetDisplayMode);
 	cellResc.AddFunc(0x2ea3061e, cellRescExit);
 	cellResc.AddFunc(0x516ee89e, cellRescInit);
 	cellResc.AddFunc(0x5a338cdb, cellRescGetBufferSize);
-	//cellResc.AddFunc(0x66f5e388, cellRescGetLastFlipTime);
+	cellResc.AddFunc(0x66f5e388, cellRescGetLastFlipTime);
 	cellResc.AddFunc(0x6cd0f95f, cellRescSetSrc);
-	//cellResc.AddFunc(0x7af8a37f, cellRescSetRegisterCount);
+	cellResc.AddFunc(0x7af8a37f, cellRescSetRegisterCount);
 	cellResc.AddFunc(0x8107277c, cellRescSetBufferAddress);
 	cellResc.AddFunc(0xc47c5c22, cellRescGetFlipStatus);
 	cellResc.AddFunc(0xd1ca0503, cellRescVideoOutResolutionId2RescBufferMode);
-	//cellResc.AddFunc(0xd3758645, cellRescSetVBlankHandler);
+	cellResc.AddFunc(0xd3758645, cellRescSetVBlankHandler);
-	//cellResc.AddFunc(0xe0cef79e, cellRescCreateInterlaceTable);
+	cellResc.AddFunc(0xe0cef79e, cellRescCreateInterlaceTable);
 }
 
 void cellResc_load()