MoonsideGames
/
Refresh
1
0
Fork 1
Code Issues 1 Pull Requests 2 Projects Releases 33 Wiki Activity

Compare commits

base: MoonsideGames:main
Branches Tags
MoonsideGames:d3d11
MoonsideGames:abi_break
MoonsideGames:main
MoonsideGames:1.15.4
MoonsideGames:1.15.3
MoonsideGames:1.15.2
MoonsideGames:1.15.1
MoonsideGames:1.15.0
MoonsideGames:1.14.1
MoonsideGames:1.14.0
MoonsideGames:1.13.1
MoonsideGames:1.13.0
MoonsideGames:1.12.0
MoonsideGames:1.11.0
MoonsideGames:1.10.0
MoonsideGames:1.9.0
MoonsideGames:1.8.2
MoonsideGames:1.8.1
MoonsideGames:1.8.0
MoonsideGames:1.7.1
MoonsideGames:1.7.0
MoonsideGames:1.6.1
MoonsideGames:1.6.0
MoonsideGames:1.5.4
MoonsideGames:1.5.3
MoonsideGames:1.5.2
MoonsideGames:1.5.1
MoonsideGames:1.5.0
MoonsideGames:1.4.0
MoonsideGames:1.3.0
MoonsideGames:1.2.2
MoonsideGames:1.2.1
MoonsideGames:1.2.0
MoonsideGames:1.1.0
MoonsideGames:1.0.0
MoonsideGames:0.1.0
..
compare: MoonsideGames:1.12.0
Branches Tags
MoonsideGames:d3d11
MoonsideGames:abi_break
MoonsideGames:main
MoonsideGames:1.15.4
MoonsideGames:1.15.3
MoonsideGames:1.15.2
MoonsideGames:1.15.1
MoonsideGames:1.15.0
MoonsideGames:1.14.1
MoonsideGames:1.14.0
MoonsideGames:1.13.1
MoonsideGames:1.13.0
MoonsideGames:1.12.0
MoonsideGames:1.11.0
MoonsideGames:1.10.0
MoonsideGames:1.9.0
MoonsideGames:1.8.2
MoonsideGames:1.8.1
MoonsideGames:1.8.0
MoonsideGames:1.7.1
MoonsideGames:1.7.0
MoonsideGames:1.6.1
MoonsideGames:1.6.0
MoonsideGames:1.5.4
MoonsideGames:1.5.3
MoonsideGames:1.5.2
MoonsideGames:1.5.1
MoonsideGames:1.5.0
MoonsideGames:1.4.0
MoonsideGames:1.3.0
MoonsideGames:1.2.2
MoonsideGames:1.2.1
MoonsideGames:1.2.0
MoonsideGames:1.1.0
MoonsideGames:1.0.0
MoonsideGames:0.1.0

No commits in common. "main" and "1.12.0" have entirely different histories.
main ... 1.12.0

12 changed files with 2186 additions and 3056 deletions
Show Stats Expand all files Collapse all files

9
CMakeLists.txt
View File

@ -8,8 +8,8 @@ option(BUILD_SHARED_LIBS "Build shared library" ON)
# Version
SET(LIB_MAJOR_VERSION "1")
SET(LIB_MINOR_VERSION "15")
SET(LIB_REVISION "4")
SET(LIB_MINOR_VERSION "12")
SET(LIB_REVISION "0")
SET(LIB_VERSION "${LIB_MAJOR_VERSION}.${LIB_MINOR_VERSION}.${LIB_REVISION}")
# Build Type
@ -60,11 +60,6 @@ if(NOT MSVC)
set_property(TARGET Refresh PROPERTY COMPILE_FLAGS "-std=gnu99 -Wall -Wno-strict-aliasing -pedantic")
endif()
# Windows is silly and we need to manually include the Vulkan SDK
if(MSVC)
target_include_directories(Refresh PUBLIC $ENV{VULKAN_SDK}/include)
endif()
# Refresh folders as includes, for other targets to consume
target_include_directories(Refresh PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>

78
include/Refresh.h
View File

@ -55,8 +55,8 @@ extern "C" {
/* Version API */
#define REFRESH_MAJOR_VERSION 1
#define REFRESH_MINOR_VERSION 15
#define REFRESH_PATCH_VERSION 4
#define REFRESH_MINOR_VERSION 12
#define REFRESH_PATCH_VERSION 0
#define REFRESH_COMPILED_VERSION ( \
(REFRESH_MAJOR_VERSION * 100 * 100) + \
@ -76,7 +76,6 @@ typedef struct Refresh_ShaderModule Refresh_ShaderModule;
typedef struct Refresh_ComputePipeline Refresh_ComputePipeline;
typedef struct Refresh_GraphicsPipeline Refresh_GraphicsPipeline;
typedef struct Refresh_CommandBuffer Refresh_CommandBuffer;
typedef struct Refresh_Fence Refresh_Fence;
typedef enum Refresh_PresentMode
{
@ -779,20 +778,15 @@ REFRESHAPI void Refresh_SetTextureData(
/* Uploads YUV image data to three R8 texture objects.
*
* y: The texture storing the Y data.
* u: The texture storing the U (Cb) data.
* v: The texture storing the V (Cr) data.
* yWidth: The width of the Y plane.
* yHeight: The height of the Y plane.
* uvWidth: The width of the U/V planes.
* uvHeight: The height of the U/V planes.
* yData: A pointer to the raw Y image data.
* uData: A pointer to the raw U image data.
* vData: A pointer to the raw V image data.
* yDataLength: The size of the Y image data in bytes.
* uvDataLength: The size of the UV image data in bytes.
* yStride: The length of a Y image data row in bytes.
* uvStride: The length of a UV image data row in bytes.
* y: The texture storing the Y data.
* u: The texture storing the U (Cb) data.
* v: The texture storing the V (Cr) data.
* yWidth: The width of the Y plane.
* yHeight: The height of the Y plane.
* uvWidth: The width of the U/V planes.
* uvHeight: The height of the U/V planes.
* data: A pointer to the raw YUV image data.
* dataLength: The size of the image data in bytes.
*/
REFRESHAPI void Refresh_SetTextureDataYUV(
Refresh_Device *driverData,
@ -804,13 +798,8 @@ REFRESHAPI void Refresh_SetTextureDataYUV(
uint32_t yHeight,
uint32_t uvWidth,
uint32_t uvHeight,
void *yDataPtr,
void *uDataPtr,
void *vDataPtr,
uint32_t yDataLength,
uint32_t uvDataLength,
uint32_t yStride,
uint32_t uvStride
void* data,
uint32_t dataLength
);
/* Performs an asynchronous texture-to-texture copy.
@ -1207,50 +1196,15 @@ REFRESHAPI Refresh_Texture* Refresh_AcquireSwapchainTexture(
/* Submits all of the enqueued commands. */
REFRESHAPI void Refresh_Submit(
Refresh_Device* device,
Refresh_CommandBuffer *commandBuffer
uint32_t commandBufferCount,
Refresh_CommandBuffer **pCommandBuffers
);
/* Submits a command buffer and acquires a fence.
* You can use the fence to check if or wait until the command buffer has finished processing.
* You are responsible for releasing this fence when you are done using it.
*/
REFRESHAPI Refresh_Fence* Refresh_SubmitAndAcquireFence(
Refresh_Device* device,
Refresh_CommandBuffer *commandBuffer
);
/* Waits for the device to become idle. */
/* Waits for all submissions to complete. */
REFRESHAPI void Refresh_Wait(
Refresh_Device *device
);
/* Waits for given fences to be signaled.
*
* waitAll: If 0, waits for any fence to be signaled. If 1, waits for all fences to be signaled.
* fenceCount: The number of fences being submitted.
* pFences: An array of fences to be waited on.
*/
REFRESHAPI void Refresh_WaitForFences(
Refresh_Device *device,
uint8_t waitAll,
uint32_t fenceCount,
Refresh_Fence **pFences
);
/* Check the status of a fence. 1 means the fence is signaled. */
REFRESHAPI int Refresh_QueryFence(
Refresh_Device *device,
Refresh_Fence *fence
);
/* Allows the fence to be reused by future command buffer submissions.
* If you do not release fences after acquiring them, you will cause unbounded resource growth.
*/
REFRESHAPI void Refresh_ReleaseFence(
Refresh_Device *device,
Refresh_Fence *fence
);
#ifdef __cplusplus
}
#endif /* __cplusplus */

106
include/Refresh_Image.h
View File

@ -44,45 +44,115 @@
extern "C" {
#endif /* __cplusplus */
/* Image Read API */
/* Decodes image data into raw RGBA8 texture data.
/* Decodes PNG data into raw RGBA8 texture data.
*
* w: Filled with the width of the image.
* h: Filled with the height of the image.
* len: Filled with the length of pixel data in bytes.
* numChannels: Filled with the number of channels in the image.
*
* Returns a block of memory suitable for use with Refresh_SetTextureData2D.
* Be sure to free the memory with Refresh_Image_Free after use!
* Be sure to free the memory with Refresh_Image_FreePNG after use!
*/
REFRESHAPI uint8_t* Refresh_Image_Load(
uint8_t *bufferPtr,
REFRESHAPI uint8_t* Refresh_Image_LoadPNGFromFile(
char const *filename,
int32_t *w,
int32_t *h,
int32_t *numChannels
);
/* Decodes PNG data into raw RGBA8 texture data.
*
* w: Filled with the width of the image.
* h: Filled with the height of the image.
* numChannels: Filled with the number of channels in the image.
*
* Returns a block of memory suitable for use with Refresh_SetTextureData2D.
* Be sure to free the memory with Refresh_Image_FreePNG after use!
*/
REFRESHAPI uint8_t* Refresh_Image_LoadPNGFromMemory(
uint8_t *buffer,
int32_t bufferLength,
int32_t *w,
int32_t *h,
int32_t *len
int32_t *numChannels
);
/* Frees memory returned by Refresh_Image_Load. Do NOT free the memory yourself!
/* Frees memory returned by Refresh_Image_LoadPNG functions. (Do NOT free the memory yourself!)
*
* mem: A pointer previously returned by Refresh_Image_LoadPNG.
*/
REFRESHAPI void Refresh_Image_Free(uint8_t *mem);
REFRESHAPI void Refresh_Image_FreePNG(uint8_t *mem);
/* Decodes QOI data into raw RGBA8 texture data.
*
* w: Filled with the width of the image.
* h: Filled with the height of the image.
* numChannels: Filled with the number of channels in the image.
*
* Returns a block of memory suitable for use with Refresh_SetTextureData2D.
* Be sure to free the memory with Refresh_Image_FreeQOI after use!
*/
REFRESHAPI uint8_t* Refresh_Image_LoadQOIFromFile(
char const *filename,
int32_t *w,
int32_t *h,
int32_t *numChannels
);
/* Decodes QOI data into raw RGBA8 texture data.
*
* bufferLength: The length of the input buffer to be decoded.
* w: Filled with the width of the image.
* h: Filled with the height of the image.
* numChannels: Filled with the number of channels in the image.
*
* Returns a block of memory suitable for use with Refresh_SetTextureData2D.
* Be sure to free the memory with Refresh_Image_FreeQOI after use!
*/
REFRESHAPI uint8_t* Refresh_Image_LoadQOIFromMemory(
uint8_t *buffer,
int32_t bufferLength,
int32_t *w,
int32_t *h,
int32_t *numChannels
);
/* Frees memory returned by Refresh_Image_LoadQOI functions. (Do NOT free the memory yourself!)
*
* mem: A pointer previously returned by Refresh_Image_LoadQOI.
*/
REFRESHAPI void Refresh_Image_FreeQOI(uint8_t *mem);
/* Image Write API */
/* Returns a buffer of PNG encoded from RGBA8 color data.
/* Encodes 32-bit color data into PNG data.
*
* data: The raw color data.
* w: The width of the color data.
* h: The height of the color data.
* len: Filled with the length of PNG data in bytes.
* filename: The filename that the image will be written to.
* w: The width of the PNG data.
* h: The height of the PNG data.
* bgra: Whether the data is in BGRA8 format. Otherwise will assume RBGA8.
* data: The raw color data.
*/
REFRESHAPI void Refresh_Image_SavePNG(
const char* filename,
uint8_t* data,
char const *filename,
int32_t w,
int32_t h
int32_t h,
uint8_t bgra,
uint8_t *data
);
/* Encodes 32-bit color data into PNG data.
*
* filename: The filename that the image will be written to.
* w: The width of the PNG data.
* h: The height of the PNG data.
* data: The raw color data.
*/
REFRESHAPI void Refresh_Image_SaveQOI(
char const *filename,
int32_t w,
int32_t h,
uint8_t *data
);
#ifdef __cplusplus

4
shadercompiler/Program.cs
View File

@ -238,7 +238,7 @@ partial class Program
{
Process glslc = Process.Start(
"glslc",
$"\"{glslPath}\" -o \"{outputPath}\""
$"{glslPath} -o {outputPath}"
);
glslc.WaitForExit();
if (glslc.ExitCode != 0)
@ -254,7 +254,7 @@ partial class Program
{
Process spirvcross = Process.Start(
"spirv-cross",
$"\"{spirvPath}\" --hlsl --shader-model 50 --output \"{outputPath}\""
$"{spirvPath} --hlsl --shader-model 50 --output {outputPath}"
);
spirvcross.WaitForExit();
if (spirvcross.ExitCode != 0)

75
src/Refresh.c
View File

@ -438,13 +438,8 @@ void Refresh_SetTextureDataYUV(
uint32_t yHeight,
uint32_t uvWidth,
uint32_t uvHeight,
void *yDataPtr,
void *uDataPtr,
void *vDataPtr,
uint32_t yDataLength,
uint32_t uvDataLength,
uint32_t yStride,
uint32_t uvStride
void* data,
uint32_t dataLength
) {
NULL_RETURN(device);
device->SetTextureDataYUV(
@ -457,13 +452,8 @@ void Refresh_SetTextureDataYUV(
yHeight,
uvWidth,
uvHeight,
yDataPtr,
uDataPtr,
vDataPtr,
yDataLength,
uvDataLength,
yStride,
uvStride
data,
dataLength
);
}
@ -892,23 +882,14 @@ void Refresh_SetSwapchainPresentMode(
void Refresh_Submit(
Refresh_Device *device,
Refresh_CommandBuffer *commandBuffer
uint32_t commandBufferCount,
Refresh_CommandBuffer **pCommandBuffers
) {
NULL_RETURN(device);
device->Submit(
device->driverData,
commandBuffer
);
}
Refresh_Fence* Refresh_SubmitAndAcquireFence(
Refresh_Device *device,
Refresh_CommandBuffer *commandBuffer
) {
NULL_RETURN_NULL(device);
return device->SubmitAndAcquireFence(
device->driverData,
commandBuffer
commandBufferCount,
pCommandBuffers
);
}
@ -921,44 +902,4 @@ void Refresh_Wait(
);
}
void Refresh_WaitForFences(
Refresh_Device *device,
uint8_t waitAll,
uint32_t fenceCount,
Refresh_Fence **pFences
) {
NULL_RETURN(device);
device->WaitForFences(
device->driverData,
waitAll,
fenceCount,
pFences
);
}
int Refresh_QueryFence(
Refresh_Device *device,
Refresh_Fence *fence
) {
if (device == NULL) {
return 0;
}
return device->QueryFence(
device->driverData,
fence
);
}
void Refresh_ReleaseFence(
Refresh_Device *device,
Refresh_Fence *fence
) {
NULL_RETURN(device);
device->ReleaseFence(
device->driverData,
fence
);
}
/* vim: set noexpandtab shiftwidth=8 tabstop=8: */

98
src/Refresh_Driver.h
View File

@ -268,7 +268,7 @@ struct Refresh_Device
/* Setters */
void (*SetTextureData)(
void(*SetTextureData)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_TextureSlice *textureSlice,
@ -276,7 +276,7 @@ struct Refresh_Device
uint32_t dataLengthInBytes
);
void (*SetTextureDataYUV)(
void(*SetTextureDataYUV)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer* commandBuffer,
Refresh_Texture *y,
@ -286,16 +286,11 @@ struct Refresh_Device
uint32_t yHeight,
uint32_t uvWidth,
uint32_t uvHeight,
void *yDataPtr,
void *uDataPtr,
void *vDataPtr,
uint32_t yDataLength,
uint32_t uvDataLength,
uint32_t yStride,
uint32_t uvStride
void* data,
uint32_t dataLength
);
void (*CopyTextureToTexture)(
void(*CopyTextureToTexture)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_TextureSlice *sourceTextureSlice,
@ -303,14 +298,14 @@ struct Refresh_Device
Refresh_Filter filter
);
void (*CopyTextureToBuffer)(
void(*CopyTextureToBuffer)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_TextureSlice *textureSlice,
Refresh_Buffer *buffer
);
void (*SetBufferData)(
void(*SetBufferData)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Buffer *buffer,
@ -319,14 +314,14 @@ struct Refresh_Device
uint32_t dataLength
);
uint32_t (*PushVertexShaderUniforms)(
uint32_t(*PushVertexShaderUniforms)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
void *data,
uint32_t dataLengthInBytes
);
uint32_t (*PushFragmentShaderUniforms)(
uint32_t(*PushFragmentShaderUniforms)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
void *data,
@ -340,14 +335,14 @@ struct Refresh_Device
uint32_t dataLengthInBytes
);
void (*BindVertexSamplers)(
void(*BindVertexSamplers)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Texture **pTextures,
Refresh_Sampler **pSamplers
);
void (*BindFragmentSamplers)(
void(*BindFragmentSamplers)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Texture **pTextures,
@ -356,7 +351,7 @@ struct Refresh_Device
/* Getters */
void (*GetBufferData)(
void(*GetBufferData)(
Refresh_Renderer *driverData,
Refresh_Buffer *buffer,
void *data,
@ -365,39 +360,39 @@ struct Refresh_Device
/* Disposal */
void (*QueueDestroyTexture)(
void(*QueueDestroyTexture)(
Refresh_Renderer *driverData,
Refresh_Texture *texture
);
void (*QueueDestroySampler)(
void(*QueueDestroySampler)(
Refresh_Renderer *driverData,
Refresh_Sampler *sampler
);
void (*QueueDestroyBuffer)(
void(*QueueDestroyBuffer)(
Refresh_Renderer *driverData,
Refresh_Buffer *buffer
);
void (*QueueDestroyShaderModule)(
void(*QueueDestroyShaderModule)(
Refresh_Renderer *driverData,
Refresh_ShaderModule *shaderModule
);
void (*QueueDestroyComputePipeline)(
void(*QueueDestroyComputePipeline)(
Refresh_Renderer *driverData,
Refresh_ComputePipeline *computePipeline
);
void (*QueueDestroyGraphicsPipeline)(
void(*QueueDestroyGraphicsPipeline)(
Refresh_Renderer *driverData,
Refresh_GraphicsPipeline *graphicsPipeline
);
/* Graphics State */
void (*BeginRenderPass)(
void(*BeginRenderPass)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_ColorAttachmentInfo *colorAttachmentInfos,
@ -405,30 +400,30 @@ struct Refresh_Device
Refresh_DepthStencilAttachmentInfo *depthStencilAttachmentInfo
);
void (*EndRenderPass)(
void(*EndRenderPass)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer
);
void (*SetViewport)(
void(*SetViewport)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Viewport *viewport
);
void (*SetScissor)(
void(*SetScissor)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Rect *scissor
);
void (*BindGraphicsPipeline)(
void(*BindGraphicsPipeline)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_GraphicsPipeline *graphicsPipeline
);
void (*BindVertexBuffers)(
void(*BindVertexBuffers)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
uint32_t firstBinding,
@ -437,7 +432,7 @@ struct Refresh_Device
uint64_t *pOffsets
);
void (*BindIndexBuffer)(
void(*BindIndexBuffer)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Buffer *buffer,
@ -445,19 +440,19 @@ struct Refresh_Device
Refresh_IndexElementSize indexElementSize
);
void (*BindComputePipeline)(
void(*BindComputePipeline)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_ComputePipeline *computePipeline
);
void (*BindComputeBuffers)(
void(*BindComputeBuffers)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Buffer **pBuffers
);
void (*BindComputeTextures)(
void(*BindComputeTextures)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Texture **pTextures
@ -469,7 +464,7 @@ struct Refresh_Device
Refresh_PresentMode presentMode
);
void (*UnclaimWindow)(
void(*UnclaimWindow)(
Refresh_Renderer *driverData,
void *windowHandle
);
@ -497,37 +492,16 @@ struct Refresh_Device
Refresh_PresentMode presentMode
);
void (*Submit)(
void(*Submit)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer
uint32_t commandBufferCount,
Refresh_CommandBuffer **pCommandBuffers
);
Refresh_Fence* (*SubmitAndAcquireFence)(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer
);
void (*Wait)(
void(*Wait)(
Refresh_Renderer *driverData
);
void (*WaitForFences)(
Refresh_Renderer *driverData,
uint8_t waitAll,
uint32_t fenceCount,
Refresh_Fence **pFences
);
int (*QueryFence)(
Refresh_Renderer *driverData,
Refresh_Fence *fence
);
void (*ReleaseFence)(
Refresh_Renderer *driverData,
Refresh_Fence *fence
);
/* Opaque pointer for the Driver */
Refresh_Renderer *driverData;
};
@ -581,11 +555,7 @@ struct Refresh_Device
ASSIGN_DRIVER_FUNC(GetSwapchainFormat, name) \
ASSIGN_DRIVER_FUNC(SetSwapchainPresentMode, name) \
ASSIGN_DRIVER_FUNC(Submit, name) \
ASSIGN_DRIVER_FUNC(SubmitAndAcquireFence, name) \
ASSIGN_DRIVER_FUNC(Wait, name) \
ASSIGN_DRIVER_FUNC(WaitForFences, name) \
ASSIGN_DRIVER_FUNC(QueryFence, name) \
ASSIGN_DRIVER_FUNC(ReleaseFence, name)
ASSIGN_DRIVER_FUNC(Wait, name)
typedef struct Refresh_Driver
{

102
src/Refresh_Driver_Template.txt
View File

@ -268,19 +268,6 @@ static void TEMPLATE_DrawPrimitives(
NOT_IMPLEMENTED
}
static void TEMPLATE_DrawPrimitivesIndirect(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Buffer *buffer,
uint32_t offsetInBytes,
uint32_t drawCount,
uint32_t stride,
uint32_t vertexParamOffset,
uint32_t fragmentParamOffset
) {
NOT_IMPLEMENTED
}
static void TEMPLATE_DispatchCompute(
Refresh_Renderer *device,
Refresh_CommandBuffer *commandBuffer,
@ -360,13 +347,8 @@ static void TEMPLATE_SetTextureDataYUV(
uint32_t yHeight,
uint32_t uvWidth,
uint32_t uvHeight,
void *yDataPtr,
void *uDataPtr,
void *vDataPtr,
uint32_t yDataLength,
uint32_t uvDataLength,
uint32_t yStride,
uint32_t uvStride
void* data,
uint32_t dataLength
) {
NOT_IMPLEMENTED
}
@ -503,15 +485,10 @@ static void TEMPLATE_QueueDestroyGraphicsPipeline(
/* Graphics State */
static Refresh_CommandBuffer* TEMPLATE_AcquireCommandBuffer(
Refresh_Renderer *driverData
) {
NOT_IMPLEMENTED
}
static void TEMPLATE_BeginRenderPass(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
Refresh_Rect *renderArea,
Refresh_ColorAttachmentInfo *colorAttachmentInfos,
uint32_t colorAttachmentCount,
Refresh_DepthStencilAttachmentInfo *depthStencilAttachmentInfo
@ -571,8 +548,6 @@ static void TEMPLATE_BindIndexBuffer(
NOT_IMPLEMENTED
}
/* Compute State */
static void TEMPLATE_BindComputePipeline(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
@ -597,24 +572,14 @@ static void TEMPLATE_BindComputeTextures(
NOT_IMPLEMENTED
}
/* Window and Swapchain Management */
static uint8_t TEMPLATE_ClaimWindow(
static Refresh_CommandBuffer* TEMPLATE_AcquireCommandBuffer(
Refresh_Renderer *driverData,
void *windowHandle,
Refresh_PresentMode presentMode
uint8_t fixed
) {
NOT_IMPLEMENTED
}
static void TEMPLATE_UnclaimWindow(
Refresh_Renderer *driverData,
void *windowHandle
) {
NOT_IMPLEMENTED
}
static Refresh_Texture* TEMPLATE_AcquireSwapchainTexture(
Refresh_Texture* TEMPLATE_AcquireSwapchainTexture(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer,
void *windowHandle,
@ -624,33 +589,17 @@ static Refresh_Texture* TEMPLATE_AcquireSwapchainTexture(
NOT_IMPLEMENTED
}
static Refresh_TextureFormat TEMPLATE_GetSwapchainFormat(
Refresh_TextureFormat TEMPLATE_GetSwapchainFormat(
Refresh_Renderer *driverData,
void *windowHandle
) {
NOT_IMPLEMENTED
}
static void TEMPLATE_SetSwapchainPresentMode(
Refresh_Renderer *driverData,
void *windowHandle,
Refresh_PresentMode presentMode
) {
NOT_IMPLEMENTED
}
/* Submission and Fences */
static void TEMPLATE_Submit(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer
) {
NOT_IMPLEMENTED
}
static Refresh_Fence* TEMPLATE_SubmitAndAcquireFence(
Refresh_Renderer *driverData,
Refresh_CommandBuffer *commandBuffer
uint32_t commandBufferCount,
Refresh_CommandBuffer **pCommandBuffers
) {
NOT_IMPLEMENTED
}
@ -661,38 +610,8 @@ static void TEMPLATE_Wait(
NOT_IMPLEMENTED
}
static void TEMPLATE_WaitForFences(
Refresh_Renderer *driverData,
uint8_t waitAll,
uint32_t fenceCount,
Refresh_Fence **pFences
) {
NOT_IMPLEMENTED
}
static int TEMPLATE_QueryFence(
Refresh_Renderer *driverData,
Refresh_Fence *fence
) {
NOT_IMPLEMENTED
}
static void TEMPLATE_ReleaseFence(
Refresh_Renderer *driverData,
Refresh_Fence *fence
) {
NOT_IMPLEMENTED
}
/* Device Creation */
static uint8_t TEMPLATE_PrepareDriver(
uint32_t *flags
) {
NOT_IMPLEMENTED
}
static Refresh_Device* TEMPLATE_CreateDevice(
Refresh_PresentationParameters *presentationParameters,
uint8_t debugMode
) {
NOT_IMPLEMENTED
@ -700,7 +619,6 @@ static Refresh_Device* TEMPLATE_CreateDevice(
Refresh_Driver TEMPLATEDriver = {
"TEMPLATE",
TEMPLATE_PrepareDriver,
TEMPLATE_CreateDevice
};

3372
src/Refresh_Driver_Vulkan.c
View File

File diff suppressed because it is too large Load Diff

1
src/Refresh_Driver_Vulkan_vkfuncs.h
View File

@ -89,7 +89,6 @@ VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdClearDepthStencilImage, (VkCommandBuff
VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyBuffer, (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions))
VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyBufferToImage, (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions))
VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyImageToBuffer, (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions))
VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdCopyImage, (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions))
VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdDispatch, (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ))
VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdDraw, (VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance))
VULKAN_DEVICE_FUNCTION(BaseVK, void, vkCmdDrawIndexed, (VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance))

150
src/Refresh_Image.c
View File

@ -76,7 +76,6 @@
/* These are per the Texture2D.FromStream spec */
#define STBI_ONLY_PNG
#define STBI_ONLY_QOI
/* These are per the Texture2D.SaveAs* spec */
#define STBIW_ONLY_PNG
@ -147,6 +146,12 @@ SDL_SIMDRealloc(void *mem, const size_t len)
#endif
#include "stb_image.h"
#define QOI_IMPLEMENTATION
#define QOI_MALLOC SDL_SIMDAlloc
#define QOI_FREE SDL_SIMDFree
#define QOI_ZEROARR SDL_zero
#include "qoi.h"
#define MINIZ_NO_STDIO
#define MINIZ_NO_TIME
#define MINIZ_SDL_MALLOC
@ -186,73 +191,110 @@ static unsigned char* dgibson_stbi_zlib_compress(
/* Image Read API */
uint8_t* Refresh_Image_Load(
uint8_t *bufferPtr,
uint8_t* Refresh_Image_LoadPNGFromFile(
char const *filename,
int32_t *w,
int32_t *h,
int32_t *numChannels
) {
return stbi_load(filename, w, h, numChannels, STBI_rgb_alpha);
}
uint8_t* Refresh_Image_LoadPNGFromMemory(
uint8_t *buffer,
int32_t bufferLength,
int32_t *w,
int32_t *h,
int32_t *len
int32_t *numChannels
) {
uint8_t* result;
uint8_t* pixels;
int32_t format;
int32_t i;
result = stbi_load_from_memory(
bufferPtr,
bufferLength,
w,
h,
&format,
STBI_rgb_alpha
);
if (result == NULL)
{
SDL_LogWarn(SDL_LOG_CATEGORY_ERROR, "Image loading failed: %s", stbi_failure_reason());
}
/* Ensure that the alpha pixels are... well, actual alpha.
* You think this looks stupid, but be assured: Your paint program is
* almost certainly even stupider.
* -flibit
*/
pixels = result;
*len = (*w) * (*h) *4;
for (i = 0; i < *len; i += 4, pixels += 4)
{
if (pixels[3] == 0)
{
pixels[0] = 0;
pixels[1] = 1;
pixels[2] = 2;
}
}
return result;
return stbi_load_from_memory(buffer, bufferLength, w, h, numChannels, STBI_rgb_alpha);
}
void Refresh_Image_Free(uint8_t *mem)
void Refresh_Image_FreePNG(uint8_t *mem)
{
SDL_SIMDFree(mem);
stbi_image_free(mem);
}
uint8_t *Refresh_Image_LoadQOIFromFile(
char const *filename,
int32_t *w,
int32_t *h,
int32_t *numChannels
) {
qoi_desc desc;
uint8_t *pixels = qoi_read(filename, &desc, 0);
*w = desc.width;
*h = desc.height;
*numChannels = desc.channels;
return pixels;
}
uint8_t* Refresh_Image_LoadQOIFromMemory(
uint8_t *buffer,
int32_t bufferLength,
int32_t *w,
int32_t *h,
int32_t *numChannels
) {
qoi_desc desc;
uint8_t *pixels = qoi_decode(buffer, bufferLength, &desc, 0);
*w = desc.width;
*h = desc.height;
*numChannels = desc.channels;
return pixels;
}
void Refresh_Image_FreeQOI(uint8_t *mem)
{
QOI_FREE(mem);
}
/* Image Write API */
void Refresh_Image_SavePNG(
const char* filename,
uint8_t* data,
const char *filename,
int32_t w,
int32_t h
int32_t h,
uint8_t bgra,
uint8_t *data
) {
stbi_write_png(
filename,
w,
h,
4,
data,
w * 4
);
uint32_t i;
uint8_t *bgraData;
if (bgra)
{
bgraData = SDL_malloc(w * h * 4);
for (i = 0; i < w * h * 4; i += 4)
{
bgraData[i] = data[i + 2];
bgraData[i + 1] = data[i + 1];
bgraData[i + 2] = data[i];
bgraData[i + 3] = data[i + 3];
}
stbi_write_png(filename, w, h, 4, bgraData, w * 4);
SDL_free(bgraData);
}
else
{
stbi_write_png(filename, w, h, 4, data, w * 4);
}
}
void Refresh_Image_SaveQOI(
char const *filename,
int32_t w,
int32_t h,
uint8_t *data
) {
qoi_desc desc;
desc.width = w;
desc.height = h;
desc.channels = 4;
desc.colorspace = QOI_LINEAR;
qoi_write(filename, data, &desc);
}
/* vim: set noexpandtab shiftwidth=8 tabstop=8: */

649
src/qoi.h Normal file
View File

@ -0,0 +1,649 @@
/*
Copyright (c) 2021, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT
QOI - The "Quite OK Image" format for fast, lossless image compression
-- About
QOI encodes and decodes images in a lossless format. Compared to stb_image and
stb_image_write QOI offers 20x-50x faster encoding, 3x-4x faster decoding and
20% better compression.
-- Synopsis
// Define `QOI_IMPLEMENTATION` in *one* C/C++ file before including this
// library to create the implementation.
#define QOI_IMPLEMENTATION
#include "qoi.h"
// Encode and store an RGBA buffer to the file system. The qoi_desc describes
// the input pixel data.
qoi_write("image_new.qoi", rgba_pixels, &(qoi_desc){
.width = 1920,
.height = 1080,
.channels = 4,
.colorspace = QOI_SRGB
});
// Load and decode a QOI image from the file system into a 32bbp RGBA buffer.
// The qoi_desc struct will be filled with the width, height, number of channels
// and colorspace read from the file header.
qoi_desc desc;
void *rgba_pixels = qoi_read("image.qoi", &desc, 4);
-- Documentation
This library provides the following functions;
- qoi_read -- read and decode a QOI file
- qoi_decode -- decode the raw bytes of a QOI image from memory
- qoi_write -- encode and write a QOI file
- qoi_encode -- encode an rgba buffer into a QOI image in memory
See the function declaration below for the signature and more information.
If you don't want/need the qoi_read and qoi_write functions, you can define
QOI_NO_STDIO before including this library.
This library uses malloc() and free(). To supply your own malloc implementation
you can define QOI_MALLOC and QOI_FREE before including this library.
This library uses memset() to zero-initialize the index. To supply your own
implementation you can define QOI_ZEROARR before including this library.
-- Data Format
A QOI file has a 14 byte header, followed by any number of data "chunks" and an
8-byte end marker.
struct qoi_header_t {
char magic[4]; // magic bytes "qoif"
uint32_t width; // image width in pixels (BE)
uint32_t height; // image height in pixels (BE)
uint8_t channels; // 3 = RGB, 4 = RGBA
uint8_t colorspace; // 0 = sRGB with linear alpha, 1 = all channels linear
};
Images are encoded row by row, left to right, top to bottom. The decoder and
encoder start with {r: 0, g: 0, b: 0, a: 255} as the previous pixel value. An
image is complete when all pixels specified by width * height have been covered.
Pixels are encoded as
- a run of the previous pixel
- an index into an array of previously seen pixels
- a difference to the previous pixel value in r,g,b
- full r,g,b or r,g,b,a values
The color channels are assumed to not be premultiplied with the alpha channel
("un-premultiplied alpha").
A running array[64] (zero-initialized) of previously seen pixel values is
maintained by the encoder and decoder. Each pixel that is seen by the encoder
and decoder is put into this array at the position formed by a hash function of
the color value. In the encoder, if the pixel value at the index matches the
current pixel, this index position is written to the stream as QOI_OP_INDEX.
The hash function for the index is:
index_position = (r * 3 + g * 5 + b * 7 + a * 11) % 64
Each chunk starts with a 2- or 8-bit tag, followed by a number of data bits. The
bit length of chunks is divisible by 8 - i.e. all chunks are byte aligned. All
values encoded in these data bits have the most significant bit on the left.
The 8-bit tags have precedence over the 2-bit tags. A decoder must check for the
presence of an 8-bit tag first.
The byte stream's end is marked with 7 0x00 bytes followed a single 0x01 byte.
The possible chunks are:
.- QOI_OP_INDEX ----------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----------------|
| 0 0 | index |
`-------------------------`
2-bit tag b00
6-bit index into the color index array: 0..63
A valid encoder must not issue 2 or more consecutive QOI_OP_INDEX chunks to the
same index. QOI_OP_RUN should be used instead.
.- QOI_OP_DIFF -----------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----+-----+-----|
| 0 1 | dr | dg | db |
`-------------------------`
2-bit tag b01
2-bit red channel difference from the previous pixel between -2..1
2-bit green channel difference from the previous pixel between -2..1
2-bit blue channel difference from the previous pixel between -2..1
The difference to the current channel values are using a wraparound operation,
so "1 - 2" will result in 255, while "255 + 1" will result in 0.
Values are stored as unsigned integers with a bias of 2. E.g. -2 is stored as
0 (b00). 1 is stored as 3 (b11).
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_LUMA -------------------------------------.
| Byte[0] | Byte[1] |
| 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |
|-------+-----------------+-------------+-----------|
| 1 0 | green diff | dr - dg | db - dg |
`---------------------------------------------------`
2-bit tag b10
6-bit green channel difference from the previous pixel -32..31
4-bit red channel difference minus green channel difference -8..7
4-bit blue channel difference minus green channel difference -8..7
The green channel is used to indicate the general direction of change and is
encoded in 6 bits. The red and blue channels (dr and db) base their diffs off
of the green channel difference and are encoded in 4 bits. I.e.:
dr_dg = (cur_px.r - prev_px.r) - (cur_px.g - prev_px.g)
db_dg = (cur_px.b - prev_px.b) - (cur_px.g - prev_px.g)
The difference to the current channel values are using a wraparound operation,
so "10 - 13" will result in 253, while "250 + 7" will result in 1.
Values are stored as unsigned integers with a bias of 32 for the green channel
and a bias of 8 for the red and blue channel.
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_RUN ------------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----------------|
| 1 1 | run |
`-------------------------`
2-bit tag b11
6-bit run-length repeating the previous pixel: 1..62
The run-length is stored with a bias of -1. Note that the run-lengths 63 and 64
(b111110 and b111111) are illegal as they are occupied by the QOI_OP_RGB and
QOI_OP_RGBA tags.
.- QOI_OP_RGB ------------------------------------------.
| Byte[0] | Byte[1] | Byte[2] | Byte[3] |
| 7 6 5 4 3 2 1 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 |
|-------------------------+---------+---------+---------|
| 1 1 1 1 1 1 1 0 | red | green | blue |
`-------------------------------------------------------`
8-bit tag b11111110
8-bit red channel value
8-bit green channel value
8-bit blue channel value
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_RGBA ---------------------------------------------------.
| Byte[0] | Byte[1] | Byte[2] | Byte[3] | Byte[4] |
| 7 6 5 4 3 2 1 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 |
|-------------------------+---------+---------+---------+---------|
| 1 1 1 1 1 1 1 1 | red | green | blue | alpha |
`-----------------------------------------------------------------`
8-bit tag b11111111
8-bit red channel value
8-bit green channel value
8-bit blue channel value
8-bit alpha channel value
*/
/* -----------------------------------------------------------------------------
Header - Public functions */
#ifndef QOI_H
#define QOI_H
#ifdef __cplusplus
extern "C" {
#endif
/* A pointer to a qoi_desc struct has to be supplied to all of qoi's functions.
It describes either the input format (for qoi_write and qoi_encode), or is
filled with the description read from the file header (for qoi_read and
qoi_decode).
The colorspace in this qoi_desc is an enum where
0 = sRGB, i.e. gamma scaled RGB channels and a linear alpha channel
1 = all channels are linear
You may use the constants QOI_SRGB or QOI_LINEAR. The colorspace is purely
informative. It will be saved to the file header, but does not affect
how chunks are en-/decoded. */
#define QOI_SRGB 0
#define QOI_LINEAR 1
typedef struct {
unsigned int width;
unsigned int height;
unsigned char channels;
unsigned char colorspace;
} qoi_desc;
#ifndef QOI_NO_STDIO
/* Encode raw RGB or RGBA pixels into a QOI image and write it to the file
system. The qoi_desc struct must be filled with the image width, height,
number of channels (3 = RGB, 4 = RGBA) and the colorspace.
The function returns 0 on failure (invalid parameters, or fopen or malloc
failed) or the number of bytes written on success. */
int qoi_write(const char *filename, const void *data, const qoi_desc *desc);
/* Read and decode a QOI image from the file system. If channels is 0, the
number of channels from the file header is used. If channels is 3 or 4 the
output format will be forced into this number of channels.
The function either returns NULL on failure (invalid data, or malloc or fopen
failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
will be filled with the description from the file header.
The returned pixel data should be free()d after use. */
void *qoi_read(const char *filename, qoi_desc *desc, int channels);
#endif /* QOI_NO_STDIO */
/* Encode raw RGB or RGBA pixels into a QOI image in memory.
The function either returns NULL on failure (invalid parameters or malloc
failed) or a pointer to the encoded data on success. On success the out_len
is set to the size in bytes of the encoded data.
The returned qoi data should be free()d after use. */
void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len);
/* Decode a QOI image from memory.
The function either returns NULL on failure (invalid parameters or malloc
failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
is filled with the description from the file header.
The returned pixel data should be free()d after use. */
void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels);
#ifdef __cplusplus
}
#endif
#endif /* QOI_H */
/* -----------------------------------------------------------------------------
Implementation */
#ifdef QOI_IMPLEMENTATION
#include <stdlib.h>
#include <string.h>
#ifndef QOI_MALLOC
#define QOI_MALLOC(sz) malloc(sz)
#define QOI_FREE(p) free(p)
#endif
#ifndef QOI_ZEROARR
#define QOI_ZEROARR(a) memset((a),0,sizeof(a))
#endif
#define QOI_OP_INDEX 0x00 /* 00xxxxxx */
#define QOI_OP_DIFF 0x40 /* 01xxxxxx */
#define QOI_OP_LUMA 0x80 /* 10xxxxxx */
#define QOI_OP_RUN 0xc0 /* 11xxxxxx */
#define QOI_OP_RGB 0xfe /* 11111110 */
#define QOI_OP_RGBA 0xff /* 11111111 */
#define QOI_MASK_2 0xc0 /* 11000000 */
#define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
#define QOI_MAGIC \
(((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
((unsigned int)'i') << 8 | ((unsigned int)'f'))
#define QOI_HEADER_SIZE 14
/* 2GB is the max file size that this implementation can safely handle. We guard
against anything larger than that, assuming the worst case with 5 bytes per
pixel, rounded down to a nice clean value. 400 million pixels ought to be
enough for anybody. */
#define QOI_PIXELS_MAX ((unsigned int)400000000)
typedef union {
struct { unsigned char r, g, b, a; } rgba;
unsigned int v;
} qoi_rgba_t;
static const unsigned char qoi_padding[8] = {0,0,0,0,0,0,0,1};
static void qoi_write_32(unsigned char *bytes, int *p, unsigned int v) {
bytes[(*p)++] = (0xff000000 & v) >> 24;
bytes[(*p)++] = (0x00ff0000 & v) >> 16;
bytes[(*p)++] = (0x0000ff00 & v) >> 8;
bytes[(*p)++] = (0x000000ff & v);
}
static unsigned int qoi_read_32(const unsigned char *bytes, int *p) {
unsigned int a = bytes[(*p)++];
unsigned int b = bytes[(*p)++];
unsigned int c = bytes[(*p)++];
unsigned int d = bytes[(*p)++];
return a << 24 | b << 16 | c << 8 | d;
}
void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len) {
int i, max_size, p, run;
int px_len, px_end, px_pos, channels;
unsigned char *bytes;
const unsigned char *pixels;
qoi_rgba_t index[64];
qoi_rgba_t px, px_prev;
if (
data == NULL || out_len == NULL || desc == NULL ||
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
desc->colorspace > 1 ||
desc->height >= QOI_PIXELS_MAX / desc->width
) {
return NULL;
}
max_size =
desc->width * desc->height * (desc->channels + 1) +
QOI_HEADER_SIZE + sizeof(qoi_padding);
p = 0;
bytes = (unsigned char *) QOI_MALLOC(max_size);
if (!bytes) {
return NULL;
}
qoi_write_32(bytes, &p, QOI_MAGIC);
qoi_write_32(bytes, &p, desc->width);
qoi_write_32(bytes, &p, desc->height);
bytes[p++] = desc->channels;
bytes[p++] = desc->colorspace;
pixels = (const unsigned char *)data;
QOI_ZEROARR(index);
run = 0;
px_prev.rgba.r = 0;
px_prev.rgba.g = 0;
px_prev.rgba.b = 0;
px_prev.rgba.a = 255;
px = px_prev;
px_len = desc->width * desc->height * desc->channels;
px_end = px_len - desc->channels;
channels = desc->channels;
for (px_pos = 0; px_pos < px_len; px_pos += channels) {
px.rgba.r = pixels[px_pos + 0];
px.rgba.g = pixels[px_pos + 1];
px.rgba.b = pixels[px_pos + 2];
if (channels == 4) {
px.rgba.a = pixels[px_pos + 3];
}
if (px.v == px_prev.v) {
run++;
if (run == 62 || px_pos == px_end) {
bytes[p++] = QOI_OP_RUN | (run - 1);
run = 0;
}
}
else {
int index_pos;
if (run > 0) {
bytes[p++] = QOI_OP_RUN | (run - 1);
run = 0;
}
index_pos = QOI_COLOR_HASH(px) % 64;
if (index[index_pos].v == px.v) {
bytes[p++] = QOI_OP_INDEX | index_pos;
}
else {
index[index_pos] = px;
if (px.rgba.a == px_prev.rgba.a) {
signed char vr = px.rgba.r - px_prev.rgba.r;
signed char vg = px.rgba.g - px_prev.rgba.g;
signed char vb = px.rgba.b - px_prev.rgba.b;
signed char vg_r = vr - vg;
signed char vg_b = vb - vg;
if (
vr > -3 && vr < 2 &&
vg > -3 && vg < 2 &&
vb > -3 && vb < 2
) {
bytes[p++] = QOI_OP_DIFF | (vr + 2) << 4 | (vg + 2) << 2 | (vb + 2);
}
else if (
vg_r > -9 && vg_r < 8 &&
vg > -33 && vg < 32 &&
vg_b > -9 && vg_b < 8
) {
bytes[p++] = QOI_OP_LUMA | (vg + 32);
bytes[p++] = (vg_r + 8) << 4 | (vg_b + 8);
}
else {
bytes[p++] = QOI_OP_RGB;
bytes[p++] = px.rgba.r;
bytes[p++] = px.rgba.g;
bytes[p++] = px.rgba.b;
}
}
else {
bytes[p++] = QOI_OP_RGBA;
bytes[p++] = px.rgba.r;
bytes[p++] = px.rgba.g;
bytes[p++] = px.rgba.b;
bytes[p++] = px.rgba.a;
}
}
}
px_prev = px;
}
for (i = 0; i < (int)sizeof(qoi_padding); i++) {
bytes[p++] = qoi_padding[i];
}
*out_len = p;
return bytes;
}
void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels) {
const unsigned char *bytes;
unsigned int header_magic;
unsigned char *pixels;
qoi_rgba_t index[64];
qoi_rgba_t px;
int px_len, chunks_len, px_pos;
int p = 0, run = 0;
if (
data == NULL || desc == NULL ||
(channels != 0 && channels != 3 && channels != 4) ||
size < QOI_HEADER_SIZE + (int)sizeof(qoi_padding)
) {
return NULL;
}
bytes = (const unsigned char *)data;
header_magic = qoi_read_32(bytes, &p);
desc->width = qoi_read_32(bytes, &p);
desc->height = qoi_read_32(bytes, &p);
desc->channels = bytes[p++];
desc->colorspace = bytes[p++];
if (
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
desc->colorspace > 1 ||
header_magic != QOI_MAGIC ||
desc->height >= QOI_PIXELS_MAX / desc->width
) {
return NULL;
}
if (channels == 0) {
channels = desc->channels;
}
px_len = desc->width * desc->height * channels;
pixels = (unsigned char *) QOI_MALLOC(px_len);
if (!pixels) {
return NULL;
}
QOI_ZEROARR(index);
px.rgba.r = 0;
px.rgba.g = 0;
px.rgba.b = 0;
px.rgba.a = 255;
chunks_len = size - (int)sizeof(qoi_padding);
for (px_pos = 0; px_pos < px_len; px_pos += channels) {
if (run > 0) {
run--;
}
else if (p < chunks_len) {
int b1 = bytes[p++];
if (b1 == QOI_OP_RGB) {
px.rgba.r = bytes[p++];
px.rgba.g = bytes[p++];
px.rgba.b = bytes[p++];
}
else if (b1 == QOI_OP_RGBA) {
px.rgba.r = bytes[p++];
px.rgba.g = bytes[p++];
px.rgba.b = bytes[p++];
px.rgba.a = bytes[p++];
}
else if ((b1 & QOI_MASK_2) == QOI_OP_INDEX) {
px = index[b1];
}
else if ((b1 & QOI_MASK_2) == QOI_OP_DIFF) {
px.rgba.r += ((b1 >> 4) & 0x03) - 2;
px.rgba.g += ((b1 >> 2) & 0x03) - 2;
px.rgba.b += ( b1 & 0x03) - 2;
}
else if ((b1 & QOI_MASK_2) == QOI_OP_LUMA) {
int b2 = bytes[p++];
int vg = (b1 & 0x3f) - 32;
px.rgba.r += vg - 8 + ((b2 >> 4) & 0x0f);
px.rgba.g += vg;
px.rgba.b += vg - 8 + (b2 & 0x0f);
}
else if ((b1 & QOI_MASK_2) == QOI_OP_RUN) {
run = (b1 & 0x3f);
}
index[QOI_COLOR_HASH(px) % 64] = px;
}
pixels[px_pos + 0] = px.rgba.r;
pixels[px_pos + 1] = px.rgba.g;
pixels[px_pos + 2] = px.rgba.b;
if (channels == 4) {
pixels[px_pos + 3] = px.rgba.a;
}
}
return pixels;
}
#ifndef QOI_NO_STDIO
#include <stdio.h>
int qoi_write(const char *filename, const void *data, const qoi_desc *desc) {
FILE *f = fopen(filename, "wb");
int size;
void *encoded;
if (!f) {
return 0;
}
encoded = qoi_encode(data, desc, &size);
if (!encoded) {
fclose(f);
return 0;
}
fwrite(encoded, 1, size, f);
fclose(f);
QOI_FREE(encoded);
return size;
}
void *qoi_read(const char *filename, qoi_desc *desc, int channels) {
FILE *f = fopen(filename, "rb");
int size, bytes_read;
void *pixels, *data;
if (!f) {
return NULL;
}
fseek(f, 0, SEEK_END);
size = ftell(f);
if (size <= 0) {
fclose(f);
return NULL;
}
fseek(f, 0, SEEK_SET);
data = QOI_MALLOC(size);
if (!data) {
fclose(f);
return NULL;
}
bytes_read = fread(data, 1, size, f);
fclose(f);
pixels = qoi_decode(data, bytes_read, desc, channels);
QOI_FREE(data);
return pixels;
}
#endif /* QOI_NO_STDIO */
#endif /* QOI_IMPLEMENTATION */

598
src/stb_image.h
View File

File diff suppressed because it is too large Load Diff