wash/fx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

meta: rename to fx

Browse Source
This commit is contained in:
max 🍓
2026-03-16 10:35:43 +00:00
parent 84df46489a
commit e9d0e323f0
233 changed files with 12875 additions and 12869 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
compress/CMakeLists.txt
View File

@@ -6,11 +6,11 @@ if (ZSTD_FOUND)
set(libs ${libs} ${ZSTD_LIBRARY})
set(include_dirs ${include_dirs} ${ZSTD_INCLUDE_DIR})
set(function_sources ${function_sources} ${CMAKE_CURRENT_SOURCE_DIR}/function/zstd.c)
set(defines ${defines} B_COMPRESSOR_SUPPORTED_ZSTD)
message(STATUS "Enabling ZSTD support in blue-compress")
set(defines ${defines} FX_COMPRESSOR_SUPPORTED_ZSTD)
message(STATUS "Enabling ZSTD support in fx-compress")
endif ()
add_bluelib_module(
add_fx_module(
NAME compress
DEPENDENCIES core
EXTRA_SOURCES ${function_sources}

160
compress/compressor.c
View File

@@ -1,15 +1,15 @@
#include <assert.h>
#include <blue/compress/compressor.h>
#include <blue/core/ringbuffer.h>
#include <fx/compress/compressor.h>
#include <fx/core/ringbuffer.h>
#include <stdlib.h>
#include <string.h>
#define COMPRESSOR_DISPATCH_STATIC(func, compressor, ...) \
do { \
struct compressor_data _compressor; \
enum b_status status \
enum fx_status status \
= compressor_get_data(compressor, &_compressor); \
if (!B_OK(status)) { \
if (!FX_OK(status)) { \
return status; \
} \
return func(&_compressor, __VA_ARGS__); \
@@ -17,9 +17,9 @@
#define COMPRESSOR_DISPATCH_STATIC_0(func, compressor) \
do { \
struct compressor_data _compressor; \
enum b_status status \
enum fx_status status \
= compressor_get_data(compressor, &_compressor); \
if (!B_OK(status)) { \
if (!FX_OK(status)) { \
return status; \
} \
return func(&_compressor); \
@@ -28,106 +28,106 @@
/*** PRIVATE DATA *************************************************************/
struct compressor_data {
b_compressor *c_obj;
b_compressor_class *c_ops;
b_compressor_data *c_data;
fx_compressor *c_obj;
fx_compressor_class *c_ops;
fx_compressor_data *c_data;
};
/*** PRIVATE FUNCTIONS ********************************************************/
static enum b_status compressor_get_data(
b_compressor *compressor, struct compressor_data *out)
static enum fx_status compressor_get_data(
fx_compressor *compressor, struct compressor_data *out)
{
out->c_obj = compressor;
return b_object_get_data(
compressor, B_TYPE_COMPRESSOR, NULL, (void **)&out->c_data,
return fx_object_get_data(
compressor, FX_TYPE_COMPRESSOR, NULL, (void **)&out->c_data,
(void **)&out->c_ops);
}
static enum b_status compressor_get_mode(
struct compressor_data *p, enum b_compressor_mode *out)
static enum fx_status compressor_get_mode(
struct compressor_data *p, enum fx_compressor_mode *out)
{
if (out) {
*out = p->c_data->c_mode;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status compressor_set_mode(
struct compressor_data *p, enum b_compressor_mode mode)
static enum fx_status compressor_set_mode(
struct compressor_data *p, enum fx_compressor_mode mode)
{
if (!p->c_ops->c_set_mode) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
return p->c_ops->c_set_mode(p->c_obj, mode);
}
static enum b_status compressor_set_buffer(
struct compressor_data *p, b_ringbuffer *inbuf, b_ringbuffer *outbuf)
static enum fx_status compressor_set_buffer(
struct compressor_data *p, fx_ringbuffer *inbuf, fx_ringbuffer *outbuf)
{
p->c_data->c_in = inbuf;
p->c_data->c_out = outbuf;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status compress(struct compressor_data *p)
static enum fx_status compress(struct compressor_data *p)
{
if (p->c_data->c_mode != B_COMPRESSOR_MODE_COMPRESS) {
return B_ERR_BAD_STATE;
if (p->c_data->c_mode != FX_COMPRESSOR_MODE_COMPRESS) {
return FX_ERR_BAD_STATE;
}
if (!p->c_ops->c_compress) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
return p->c_ops->c_compress(p->c_obj);
}
static enum b_status decompress(struct compressor_data *p)
static enum fx_status decompress(struct compressor_data *p)
{
if (p->c_data->c_mode != B_COMPRESSOR_MODE_DECOMPRESS) {
return B_ERR_BAD_STATE;
if (p->c_data->c_mode != FX_COMPRESSOR_MODE_DECOMPRESS) {
return FX_ERR_BAD_STATE;
}
if (!p->c_ops->c_decompress) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
return p->c_ops->c_decompress(p->c_obj);
}
static enum b_status compressor_step(struct compressor_data *p)
static enum fx_status compressor_step(struct compressor_data *p)
{
switch (p->c_data->c_mode) {
case B_COMPRESSOR_MODE_COMPRESS:
case FX_COMPRESSOR_MODE_COMPRESS:
return compress(p);
case B_COMPRESSOR_MODE_DECOMPRESS:
case FX_COMPRESSOR_MODE_DECOMPRESS:
return decompress(p);
default:
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
}
static enum b_status compressor_end(struct compressor_data *p)
static enum fx_status compressor_end(struct compressor_data *p)
{
if (p->c_data->c_mode != B_COMPRESSOR_MODE_COMPRESS) {
return B_SUCCESS;
if (p->c_data->c_mode != FX_COMPRESSOR_MODE_COMPRESS) {
return FX_SUCCESS;
}
if (!p->c_ops->c_compress_end) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
while (b_ringbuffer_available_data_remaining(p->c_data->c_in)) {
if (!b_ringbuffer_write_capacity_remaining(p->c_data->c_out)) {
return B_ERR_NO_SPACE;
while (fx_ringbuffer_available_data_remaining(p->c_data->c_in)) {
if (!fx_ringbuffer_write_capacity_remaining(p->c_data->c_out)) {
return FX_ERR_NO_SPACE;
}
enum b_status status = compressor_step(p);
if (!B_OK(status)) {
enum fx_status status = compressor_step(p);
if (!FX_OK(status)) {
return status;
}
}
@@ -135,105 +135,105 @@ static enum b_status compressor_end(struct compressor_data *p)
return p->c_ops->c_compress_end(p->c_obj);
}
static enum b_status compressor_reset(struct compressor_data *p)
static enum fx_status compressor_reset(struct compressor_data *p)
{
p->c_data->c_flags &= ~B_COMPRESSOR_EOF;
p->c_data->c_flags &= ~FX_COMPRESSOR_EOF;
if (p->c_ops->c_reset) {
return p->c_ops->c_reset(p->c_obj);
}
return B_SUCCESS;
return FX_SUCCESS;
}
static bool compressor_eof(const struct compressor_data *p)
{
return (p->c_data->c_flags & B_COMPRESSOR_EOF) != 0;
return (p->c_data->c_flags & FX_COMPRESSOR_EOF) != 0;
}
/*** PUBLIC FUNCTIONS *********************************************************/
enum b_status b_compressor_get_buffer_size(
b_type type, b_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size)
enum fx_status fx_compressor_get_buffer_size(
fx_type type, fx_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size)
{
b_class *c = b_class_get(type);
fx_class *c = fx_class_get(type);
if (!c) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
b_compressor_class *ops = b_class_get_interface(c, B_TYPE_COMPRESSOR);
fx_compressor_class *ops = fx_class_get_interface(c, FX_TYPE_COMPRESSOR);
if (!ops) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
if (!ops->c_buffer_size) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
return ops->c_buffer_size(mode, inbuf_size, outbuf_size);
}
enum b_status b_compressor_get_mode(
const b_compressor *compressor, enum b_compressor_mode *out)
enum fx_status fx_compressor_get_mode(
const fx_compressor *compressor, enum fx_compressor_mode *out)
{
COMPRESSOR_DISPATCH_STATIC(
compressor_get_mode, (b_compressor *)compressor, out);
compressor_get_mode, (fx_compressor *)compressor, out);
}
enum b_status b_compressor_set_mode(
b_compressor *compressor, enum b_compressor_mode mode)
enum fx_status fx_compressor_set_mode(
fx_compressor *compressor, enum fx_compressor_mode mode)
{
COMPRESSOR_DISPATCH_STATIC(compressor_set_mode, compressor, mode);
}
enum b_status b_compressor_set_buffer(
b_compressor *compressor, b_ringbuffer *inbuf, b_ringbuffer *outbuf)
enum fx_status fx_compressor_set_buffer(
fx_compressor *compressor, fx_ringbuffer *inbuf, fx_ringbuffer *outbuf)
{
COMPRESSOR_DISPATCH_STATIC(compressor_set_buffer, compressor, inbuf, outbuf);
}
enum b_status b_compressor_step(b_compressor *compressor)
enum fx_status fx_compressor_step(fx_compressor *compressor)
{
COMPRESSOR_DISPATCH_STATIC_0(compressor_step, compressor);
}
enum b_status b_compressor_end(b_compressor *compressor)
enum fx_status fx_compressor_end(fx_compressor *compressor)
{
COMPRESSOR_DISPATCH_STATIC_0(compressor_end, compressor);
}
enum b_status b_compressor_reset(b_compressor *compressor)
enum fx_status fx_compressor_reset(fx_compressor *compressor)
{
COMPRESSOR_DISPATCH_STATIC_0(compressor_reset, compressor);
}
bool b_compressor_eof(const b_compressor *compressor)
bool fx_compressor_eof(const fx_compressor *compressor)
{
COMPRESSOR_DISPATCH_STATIC_0(compressor_eof, (b_compressor *)compressor);
COMPRESSOR_DISPATCH_STATIC_0(compressor_eof, (fx_compressor *)compressor);
}
/*** VIRTUAL FUNCTIONS ********************************************************/
static void compressor_init(b_object *obj, void *priv)
static void compressor_init(fx_object *obj, void *priv)
{
}
static void compressor_fini(b_object *obj, void *priv)
static void compressor_fini(fx_object *obj, void *priv)
{
}
/*** CLASS DEFINITION *********************************************************/
B_TYPE_CLASS_DEFINITION_BEGIN(b_compressor)
B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT)
B_INTERFACE_ENTRY(to_string) = NULL;
B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT)
B_TYPE_CLASS_DEFINITION_END(b_compressor)
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_compressor)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
FX_INTERFACE_ENTRY(to_string) = NULL;
FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
FX_TYPE_CLASS_DEFINITION_END(fx_compressor)
B_TYPE_DEFINITION_BEGIN(b_compressor)
B_TYPE_ID(0x452ee0f9, 0xfe12, 0x48a1, 0xb596, 0xad5b7a3940e7);
B_TYPE_CLASS(b_compressor_class);
B_TYPE_INSTANCE_PROTECTED(b_compressor_data);
B_TYPE_INSTANCE_INIT(compressor_init);
B_TYPE_INSTANCE_FINI(compressor_fini);
B_TYPE_DEFINITION_END(b_compressor)
FX_TYPE_DEFINITION_BEGIN(fx_compressor)
FX_TYPE_ID(0x452ee0f9, 0xfe12, 0x48a1, 0xb596, 0xad5b7a3940e7);
FX_TYPE_CLASS(fx_compressor_class);
FX_TYPE_INSTANCE_PROTECTED(fx_compressor_data);
FX_TYPE_INSTANCE_INIT(compressor_init);
FX_TYPE_INSTANCE_FINI(compressor_fini);
FX_TYPE_DEFINITION_END(fx_compressor)

504
compress/cstream.c
View File

File diff suppressed because it is too large Load Diff

246
compress/function/zstd.c
View File

@@ -1,10 +1,10 @@
#include <blue/compress/zstd.h>
#include <blue/core/ringbuffer.h>
#include <fx/compress/zstd.h>
#include <fx/core/ringbuffer.h>
#include <zstd.h>
/*** PRIVATE DATA *************************************************************/
struct b_zstd_compressor_p {
struct fx_zstd_compressor_p {
union {
ZSTD_CCtx *zstd_c;
ZSTD_DCtx *zstd_d;
@@ -13,40 +13,40 @@ struct b_zstd_compressor_p {
/*** PUBLIC FUNCTIONS *********************************************************/
b_status b_zstd_compressor_get_buffer_size(
b_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size)
fx_status fx_zstd_compressor_get_buffer_size(
fx_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size)
{
switch (mode) {
case B_COMPRESSOR_MODE_COMPRESS:
case FX_COMPRESSOR_MODE_COMPRESS:
*inbuf_size = ZSTD_CStreamInSize();
*outbuf_size = ZSTD_CStreamOutSize();
break;
case B_COMPRESSOR_MODE_DECOMPRESS:
case FX_COMPRESSOR_MODE_DECOMPRESS:
*inbuf_size = ZSTD_DStreamInSize();
*outbuf_size = ZSTD_DStreamOutSize();
break;
default:
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
return B_SUCCESS;
return FX_SUCCESS;
}
/*** VIRTUAL FUNCTIONS ********************************************************/
static void zstd_compressor_init(b_object *obj, void *priv)
static void zstd_compressor_init(fx_object *obj, void *priv)
{
}
static void zstd_compressor_fini(b_object *obj, void *priv)
static void zstd_compressor_fini(fx_object *obj, void *priv)
{
b_compressor_data *c = b_object_get_protected(obj, B_TYPE_COMPRESSOR);
struct b_zstd_compressor_p *ctx = priv;
fx_compressor_data *c = fx_object_get_protected(obj, FX_TYPE_COMPRESSOR);
struct fx_zstd_compressor_p *ctx = priv;
switch (c->c_mode) {
case B_COMPRESSOR_MODE_COMPRESS:
case FX_COMPRESSOR_MODE_COMPRESS:
ZSTD_freeCCtx(ctx->zstd_c);
break;
case B_COMPRESSOR_MODE_DECOMPRESS:
case FX_COMPRESSOR_MODE_DECOMPRESS:
ZSTD_freeDCtx(ctx->zstd_d);
break;
default:
@@ -54,52 +54,52 @@ static void zstd_compressor_fini(b_object *obj, void *priv)
}
}
static enum b_status reset(b_compressor *compressor)
static enum fx_status reset(fx_compressor *compressor)
{
struct b_zstd_compressor_p *ctx
= b_object_get_private(compressor, B_TYPE_ZSTD_COMPRESSOR);
b_compressor_data *data
= b_object_get_protected(compressor, B_TYPE_COMPRESSOR);
struct fx_zstd_compressor_p *ctx
= fx_object_get_private(compressor, FX_TYPE_ZSTD_COMPRESSOR);
fx_compressor_data *data
= fx_object_get_protected(compressor, FX_TYPE_COMPRESSOR);
if (!ctx || !data) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
switch (data->c_mode) {
case B_COMPRESSOR_MODE_COMPRESS:
case FX_COMPRESSOR_MODE_COMPRESS:
ZSTD_CCtx_reset(ctx->zstd_c, ZSTD_reset_session_only);
break;
case B_COMPRESSOR_MODE_DECOMPRESS:
case FX_COMPRESSOR_MODE_DECOMPRESS:
ZSTD_DCtx_reset(ctx->zstd_d, ZSTD_reset_session_only);
break;
default:
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status compress(b_compressor *compressor)
static enum fx_status compress(fx_compressor *compressor)
{
enum b_status status = B_SUCCESS;
struct b_zstd_compressor_p *ctx
= b_object_get_private(compressor, B_TYPE_ZSTD_COMPRESSOR);
b_compressor_data *data
= b_object_get_protected(compressor, B_TYPE_COMPRESSOR);
enum fx_status status = FX_SUCCESS;
struct fx_zstd_compressor_p *ctx
= fx_object_get_private(compressor, FX_TYPE_ZSTD_COMPRESSOR);
fx_compressor_data *data
= fx_object_get_protected(compressor, FX_TYPE_COMPRESSOR);
if (!ctx || !data) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
b_ringbuffer *in = data->c_in;
b_ringbuffer *out = data->c_out;
fx_ringbuffer *in = data->c_in;
fx_ringbuffer *out = data->c_out;
if (b_ringbuffer_available_data_remaining(in) == 0) {
return B_ERR_NO_DATA;
if (fx_ringbuffer_available_data_remaining(in) == 0) {
return FX_ERR_NO_DATA;
}
if (b_ringbuffer_write_capacity_remaining(out) == 0) {
return B_ERR_NO_SPACE;
if (fx_ringbuffer_write_capacity_remaining(out) == 0) {
return FX_ERR_NO_SPACE;
}
size_t nr_consumed = 0;
@@ -109,15 +109,15 @@ static enum b_status compress(b_compressor *compressor)
const void *in_buf = NULL;
void *out_buf = NULL;
status = b_ringbuffer_open_read_buffer(in, &in_buf, &in_available);
if (!B_OK(status)) {
status = fx_ringbuffer_open_read_buffer(in, &in_buf, &in_available);
if (!FX_OK(status)) {
break;
}
status = b_ringbuffer_open_write_buffer(
status = fx_ringbuffer_open_write_buffer(
out, &out_buf, &out_capacity);
if (!B_OK(status)) {
b_ringbuffer_close_read_buffer(in, &in_buf, 0);
if (!FX_OK(status)) {
fx_ringbuffer_close_read_buffer(in, &in_buf, 0);
break;
}
@@ -137,49 +137,49 @@ static enum b_status compress(b_compressor *compressor)
size_t ret = ZSTD_compressStream2(
ctx->zstd_c, &z_out, &z_in, ZSTD_e_continue);
if (ZSTD_isError(ret)) {
status = B_ERR_COMPRESSION_FAILURE;
status = FX_ERR_COMPRESSION_FAILURE;
break;
}
} while (z_in.pos < z_in.size && z_out.pos < z_out.size);
nr_consumed += z_in.pos;
b_ringbuffer_close_read_buffer(in, &in_buf, z_in.pos);
b_ringbuffer_close_write_buffer(out, &out_buf, z_out.pos);
fx_ringbuffer_close_read_buffer(in, &in_buf, z_in.pos);
fx_ringbuffer_close_write_buffer(out, &out_buf, z_out.pos);
}
if ((status == B_ERR_NO_SPACE || status == B_ERR_NO_DATA)
if ((status == FX_ERR_NO_SPACE || status == FX_ERR_NO_DATA)
&& nr_consumed > 0) {
status = B_SUCCESS;
status = FX_SUCCESS;
}
return status;
}
static enum b_status compress_end(b_compressor *compressor)
static enum fx_status compress_end(fx_compressor *compressor)
{
enum b_status status = B_SUCCESS;
struct b_zstd_compressor_p *ctx
= b_object_get_private(compressor, B_TYPE_ZSTD_COMPRESSOR);
b_compressor_data *data
= b_object_get_protected(compressor, B_TYPE_COMPRESSOR);
enum fx_status status = FX_SUCCESS;
struct fx_zstd_compressor_p *ctx
= fx_object_get_private(compressor, FX_TYPE_ZSTD_COMPRESSOR);
fx_compressor_data *data
= fx_object_get_protected(compressor, FX_TYPE_COMPRESSOR);
if (!ctx || !data) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
b_ringbuffer *out = data->c_out;
if (b_ringbuffer_write_capacity_remaining(out) == 0) {
return B_ERR_NO_SPACE;
fx_ringbuffer *out = data->c_out;
if (fx_ringbuffer_write_capacity_remaining(out) == 0) {
return FX_ERR_NO_SPACE;
}
bool finished = false;
do {
void *out_buf = NULL;
size_t out_capacity = 0;
status = b_ringbuffer_open_write_buffer(
status = fx_ringbuffer_open_write_buffer(
out, &out_buf, &out_capacity);
if (!B_OK(status)) {
if (!FX_OK(status)) {
break;
}
@@ -194,61 +194,61 @@ static enum b_status compress_end(b_compressor *compressor)
size_t ret = ZSTD_compressStream2(
ctx->zstd_c, &z_out, &z_in, ZSTD_e_end);
if (ZSTD_isError(ret)) {
status = B_ERR_COMPRESSION_FAILURE;
status = FX_ERR_COMPRESSION_FAILURE;
finished = true;
}
if (ret == 0) {
data->c_flags |= B_COMPRESSOR_EOF;
data->c_flags |= FX_COMPRESSOR_EOF;
finished = true;
}
} while (!finished && z_out.pos < z_out.size);
b_ringbuffer_close_write_buffer(out, &out_buf, z_out.pos);
fx_ringbuffer_close_write_buffer(out, &out_buf, z_out.pos);
} while (!finished);
return status;
}
static enum b_status decompress(b_compressor *compressor)
static enum fx_status decompress(fx_compressor *compressor)
{
enum b_status status = B_SUCCESS;
struct b_zstd_compressor_p *ctx
= b_object_get_private(compressor, B_TYPE_ZSTD_COMPRESSOR);
b_compressor_data *data
= b_object_get_protected(compressor, B_TYPE_COMPRESSOR);
enum fx_status status = FX_SUCCESS;
struct fx_zstd_compressor_p *ctx
= fx_object_get_private(compressor, FX_TYPE_ZSTD_COMPRESSOR);
fx_compressor_data *data
= fx_object_get_protected(compressor, FX_TYPE_COMPRESSOR);
if (!ctx || !data) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
b_ringbuffer *in = data->c_in;
b_ringbuffer *out = data->c_out;
fx_ringbuffer *in = data->c_in;
fx_ringbuffer *out = data->c_out;
if (b_ringbuffer_available_data_remaining(in) == 0) {
return B_ERR_NO_DATA;
if (fx_ringbuffer_available_data_remaining(in) == 0) {
return FX_ERR_NO_DATA;
}
if (b_ringbuffer_write_capacity_remaining(out) == 0) {
return B_ERR_NO_SPACE;
if (fx_ringbuffer_write_capacity_remaining(out) == 0) {
return FX_ERR_NO_SPACE;
}
size_t nr_consumed = 0;
while (!(data->c_flags & B_COMPRESSOR_EOF)) {
while (!(data->c_flags & FX_COMPRESSOR_EOF)) {
size_t in_available = 0, out_capacity = 0;
const void *in_buf = NULL;
void *out_buf = NULL;
status = b_ringbuffer_open_read_buffer(in, &in_buf, &in_available);
if (!B_OK(status)) {
status = fx_ringbuffer_open_read_buffer(in, &in_buf, &in_available);
if (!FX_OK(status)) {
break;
}
status = b_ringbuffer_open_write_buffer(
status = fx_ringbuffer_open_write_buffer(
out, &out_buf, &out_capacity);
if (!B_OK(status)) {
b_ringbuffer_close_read_buffer(in, &in_buf, 0);
if (!FX_OK(status)) {
fx_ringbuffer_close_read_buffer(in, &in_buf, 0);
break;
}
@@ -268,50 +268,50 @@ static enum b_status decompress(b_compressor *compressor)
size_t ret = ZSTD_decompressStream(
ctx->zstd_d, &z_out, &z_in);
if (ZSTD_isError(ret)) {
status = B_ERR_COMPRESSION_FAILURE;
status = FX_ERR_COMPRESSION_FAILURE;
break;
}
if (ret == 0) {
data->c_flags |= B_COMPRESSOR_EOF;
data->c_flags |= FX_COMPRESSOR_EOF;
break;
}
} while (z_in.pos < z_in.size && z_out.pos < z_out.size);
nr_consumed += z_in.pos;
b_ringbuffer_close_read_buffer(in, &in_buf, z_in.pos);
b_ringbuffer_close_write_buffer(out, &out_buf, z_out.pos);
fx_ringbuffer_close_read_buffer(in, &in_buf, z_in.pos);
fx_ringbuffer_close_write_buffer(out, &out_buf, z_out.pos);
}
if ((status == B_ERR_NO_SPACE || status == B_ERR_NO_DATA)
if ((status == FX_ERR_NO_SPACE || status == FX_ERR_NO_DATA)
&& nr_consumed > 0) {
status = B_SUCCESS;
status = FX_SUCCESS;
}
return status;
}
static enum b_status set_mode(b_compressor *compressor, b_compressor_mode mode)
static enum fx_status set_mode(fx_compressor *compressor, fx_compressor_mode mode)
{
struct b_zstd_compressor_p *ctx
= b_object_get_private(compressor, B_TYPE_ZSTD_COMPRESSOR);
b_compressor_data *data
= b_object_get_protected(compressor, B_TYPE_COMPRESSOR);
struct fx_zstd_compressor_p *ctx
= fx_object_get_private(compressor, FX_TYPE_ZSTD_COMPRESSOR);
fx_compressor_data *data
= fx_object_get_protected(compressor, FX_TYPE_COMPRESSOR);
if (!ctx || !data) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
if (mode == data->c_mode) {
return B_SUCCESS;
return FX_SUCCESS;
}
switch (data->c_mode) {
case B_COMPRESSOR_MODE_COMPRESS:
case FX_COMPRESSOR_MODE_COMPRESS:
ZSTD_freeCCtx(ctx->zstd_c);
break;
case B_COMPRESSOR_MODE_DECOMPRESS:
case FX_COMPRESSOR_MODE_DECOMPRESS:
ZSTD_freeDCtx(ctx->zstd_d);
break;
default:
@@ -321,42 +321,42 @@ static enum b_status set_mode(b_compressor *compressor, b_compressor_mode mode)
data->c_mode = mode;
switch (data->c_mode) {
case B_COMPRESSOR_MODE_COMPRESS:
case FX_COMPRESSOR_MODE_COMPRESS:
ctx->zstd_c = ZSTD_createCCtx();
break;
case B_COMPRESSOR_MODE_DECOMPRESS:
case FX_COMPRESSOR_MODE_DECOMPRESS:
ctx->zstd_d = ZSTD_createDCtx();
break;
default:
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
return B_SUCCESS;
return FX_SUCCESS;
}
/*** CLASS DEFINITION *********************************************************/
B_TYPE_CLASS_DEFINITION_BEGIN(b_zstd_compressor)
B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT)
B_INTERFACE_ENTRY(to_string) = NULL;
B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT)
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_zstd_compressor)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
FX_INTERFACE_ENTRY(to_string) = NULL;
FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
B_TYPE_CLASS_INTERFACE_BEGIN(b_compressor, B_TYPE_COMPRESSOR)
B_INTERFACE_ENTRY(c_buffer_size)
= b_zstd_compressor_get_buffer_size;
B_INTERFACE_ENTRY(c_compress) = compress;
B_INTERFACE_ENTRY(c_compress_end) = compress_end;
B_INTERFACE_ENTRY(c_decompress) = decompress;
B_INTERFACE_ENTRY(c_reset) = reset;
B_INTERFACE_ENTRY(c_set_mode) = set_mode;
B_TYPE_CLASS_INTERFACE_END(b_compressor, B_TYPE_COMPRESSOR)
B_TYPE_CLASS_DEFINITION_END(b_zstd_compressor)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_compressor, FX_TYPE_COMPRESSOR)
FX_INTERFACE_ENTRY(c_buffer_size)
= fx_zstd_compressor_get_buffer_size;
FX_INTERFACE_ENTRY(c_compress) = compress;
FX_INTERFACE_ENTRY(c_compress_end) = compress_end;
FX_INTERFACE_ENTRY(c_decompress) = decompress;
FX_INTERFACE_ENTRY(c_reset) = reset;
FX_INTERFACE_ENTRY(c_set_mode) = set_mode;
FX_TYPE_CLASS_INTERFACE_END(fx_compressor, FX_TYPE_COMPRESSOR)
FX_TYPE_CLASS_DEFINITION_END(fx_zstd_compressor)
B_TYPE_DEFINITION_BEGIN(b_zstd_compressor)
B_TYPE_ID(0x51d437fc, 0xe789, 0x4105, 0xbac7, 0xe6b3f45df198);
B_TYPE_EXTENDS(B_TYPE_COMPRESSOR);
B_TYPE_CLASS(b_zstd_compressor_class);
B_TYPE_INSTANCE_PRIVATE(struct b_zstd_compressor_p);
B_TYPE_INSTANCE_INIT(zstd_compressor_init);
B_TYPE_INSTANCE_FINI(zstd_compressor_fini);
B_TYPE_DEFINITION_END(b_zstd_compressor)
FX_TYPE_DEFINITION_BEGIN(fx_zstd_compressor)
FX_TYPE_ID(0x51d437fc, 0xe789, 0x4105, 0xbac7, 0xe6b3f45df198);
FX_TYPE_EXTENDS(FX_TYPE_COMPRESSOR);
FX_TYPE_CLASS(fx_zstd_compressor_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_zstd_compressor_p);
FX_TYPE_INSTANCE_INIT(zstd_compressor_init);
FX_TYPE_INSTANCE_FINI(zstd_compressor_fini);
FX_TYPE_DEFINITION_END(fx_zstd_compressor)

67
compress/include/blue/compress/compressor.h
View File

@@ -1,67 +0,0 @@
#ifndef BLUE_COMPRESS_COMPRESSOR_H_
#define BLUE_COMPRESS_COMPRESSOR_H_
#include <blue/core/macros.h>
#include <blue/core/misc.h>
#include <blue/core/ringbuffer.h>
#include <blue/core/status.h>
#include <stdbool.h>
B_DECLS_BEGIN;
typedef enum b_compressor_mode {
B_COMPRESSOR_MODE_NONE = 0,
B_COMPRESSOR_MODE_COMPRESS,
B_COMPRESSOR_MODE_DECOMPRESS,
} b_compressor_mode;
typedef enum b_compressor_flags {
B_COMPRESSOR_EOF = 0x01u,
} b_compressor_flags;
#define B_TYPE_COMPRESSOR (b_compressor_get_type())
B_DECLARE_TYPE(b_compressor);
B_TYPE_CLASS_DECLARATION_BEGIN(b_compressor)
b_status (*c_buffer_size)(b_compressor_mode, size_t *, size_t *);
b_status (*c_set_mode)(b_compressor *, b_compressor_mode);
b_status (*c_compress)(b_compressor *);
b_status (*c_compress_end)(b_compressor *);
b_status (*c_decompress)(b_compressor *);
b_status (*c_reset)(b_compressor *);
B_TYPE_CLASS_DECLARATION_END(b_compressor)
typedef struct b_compressor_data {
b_compressor_flags c_flags;
b_compressor_mode c_mode;
b_ringbuffer *c_in, *c_out;
} b_compressor_data;
BLUE_API b_type b_compressor_get_type(void);
#if 0
BLUE_API b_status b_compressor_create(
const struct b_compression_function *func, enum b_compression_mode mode,
struct b_ringbuffer *inbuf, struct b_ringbuffer *outbuf,
b_compressor **out);
#endif
BLUE_API b_status b_compressor_get_buffer_size(
b_type type, b_compressor_mode mode, size_t *inbuf_size,
size_t *outbuf_size);
BLUE_API b_status b_compressor_get_mode(
const b_compressor *compressor, b_compressor_mode *out);
BLUE_API b_status b_compressor_set_mode(
b_compressor *compressor, b_compressor_mode mode);
BLUE_API b_status b_compressor_set_buffer(
b_compressor *compressor, b_ringbuffer *inbuf, b_ringbuffer *outbuf);
BLUE_API b_status b_compressor_step(b_compressor *compressor);
BLUE_API b_status b_compressor_end(b_compressor *compressor);
BLUE_API b_status b_compressor_reset(b_compressor *compressor);
BLUE_API bool b_compressor_eof(const b_compressor *compressor);
B_DECLS_END;
#endif

50
compress/include/blue/compress/cstream.h
View File

@@ -1,50 +0,0 @@
#ifndef BLUE_COMPRESS_CSTREAM_H_
#define BLUE_COMPRESS_CSTREAM_H_
#include <blue/core/macros.h>
#include <blue/core/stream.h>
#include <stdbool.h>
B_DECLS_BEGIN;
enum b_compressor_mode;
#define B_TYPE_CSTREAM (b_cstream_get_type())
B_DECLARE_TYPE(b_cstream);
B_TYPE_CLASS_DECLARATION_BEGIN(b_cstream)
B_TYPE_CLASS_DECLARATION_END(b_cstream)
BLUE_API b_type b_cstream_get_type(void);
BLUE_API b_status b_cstream_open(
b_stream *endpoint, b_type compressor_type, enum b_compressor_mode mode,
b_cstream **out);
BLUE_API b_status b_cstream_read(
b_cstream *stream, void *buf, size_t count, size_t *nr_read);
BLUE_API b_status b_cstream_write(
b_cstream *stream, const void *buf, size_t count, size_t *nr_written);
BLUE_API b_status b_cstream_skip(
b_cstream *stream, size_t count, size_t *nr_skipped);
BLUE_API b_status b_cstream_reset(b_cstream *stream);
BLUE_API b_status b_cstream_begin_compressed_section(
b_cstream *stream, size_t *tx_uncompressed_bytes);
BLUE_API b_status b_cstream_end_compressed_section(
b_cstream *stream, size_t *tx_compressed_bytes,
size_t *tx_uncompressed_bytes);
BLUE_API bool b_cstream_in_compressed_section(const b_cstream *stream);
BLUE_API b_status b_cstream_tx_bytes(const b_cstream *stream, size_t *out);
BLUE_API b_status b_cstream_tx_bytes_compressed(
const b_cstream *stream, size_t *out);
BLUE_API b_status b_cstream_tx_bytes_uncompressed(
const b_cstream *stream, size_t *out);
BLUE_API b_status b_cstream_set_cursor_position(b_cstream *stream, size_t pos);
BLUE_API b_status b_cstream_restore_cursor_position(b_cstream *stream);
B_DECLS_END;
#endif

28
compress/include/blue/compress/zstd.h
View File

@@ -1,28 +0,0 @@
#ifndef BLUE_COMPRESS_ZSTD_H_
#define BLUE_COMPRESS_ZSTD_H_
#include <blue/compress/compressor.h>
#include <blue/core/macros.h>
#include <blue/core/misc.h>
#include <blue/core/status.h>
#include <stdbool.h>
B_DECLS_BEGIN;
#define B_TYPE_ZSTD_COMPRESSOR (b_zstd_compressor_get_type())
B_DECLARE_TYPE(b_zstd_compressor);
B_TYPE_CLASS_DECLARATION_BEGIN(b_zstd_compressor)
B_TYPE_CLASS_DECLARATION_END(b_compressor)
BLUE_API b_type b_zstd_compressor_get_type(void);
BLUE_API b_status b_zstd_compressor_get_buffer_size(
b_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size);
B_TYPE_DEFAULT_CONSTRUCTOR(b_zstd_compressor, B_TYPE_ZSTD_COMPRESSOR);
B_DECLS_END;
#endif

0
compress/include/blue/compress.h → compress/include/fx/compress.h
View File

67
compress/include/fx/compress/compressor.h Normal file
View File

@@ -0,0 +1,67 @@
#ifndef FX_COMPRESS_COMPRESSOR_H_
#define FX_COMPRESS_COMPRESSOR_H_
#include <fx/core/macros.h>
#include <fx/core/misc.h>
#include <fx/core/ringbuffer.h>
#include <fx/core/status.h>
#include <stdbool.h>
FX_DECLS_BEGIN;
typedef enum fx_compressor_mode {
FX_COMPRESSOR_MODE_NONE = 0,
FX_COMPRESSOR_MODE_COMPRESS,
FX_COMPRESSOR_MODE_DECOMPRESS,
} fx_compressor_mode;
typedef enum fx_compressor_flags {
FX_COMPRESSOR_EOF = 0x01u,
} fx_compressor_flags;
#define FX_TYPE_COMPRESSOR (fx_compressor_get_type())
FX_DECLARE_TYPE(fx_compressor);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_compressor)
fx_status (*c_buffer_size)(fx_compressor_mode, size_t *, size_t *);
fx_status (*c_set_mode)(fx_compressor *, fx_compressor_mode);
fx_status (*c_compress)(fx_compressor *);
fx_status (*c_compress_end)(fx_compressor *);
fx_status (*c_decompress)(fx_compressor *);
fx_status (*c_reset)(fx_compressor *);
FX_TYPE_CLASS_DECLARATION_END(fx_compressor)
typedef struct fx_compressor_data {
fx_compressor_flags c_flags;
fx_compressor_mode c_mode;
fx_ringbuffer *c_in, *c_out;
} fx_compressor_data;
FX_API fx_type fx_compressor_get_type(void);
#if 0
FX_API fx_status fx_compressor_create(
const struct fx_compression_function *func, enum fx_compression_mode mode,
struct fx_ringbuffer *inbuf, struct fx_ringbuffer *outbuf,
fx_compressor **out);
#endif
FX_API fx_status fx_compressor_get_buffer_size(
fx_type type, fx_compressor_mode mode, size_t *inbuf_size,
size_t *outbuf_size);
FX_API fx_status fx_compressor_get_mode(
const fx_compressor *compressor, fx_compressor_mode *out);
FX_API fx_status fx_compressor_set_mode(
fx_compressor *compressor, fx_compressor_mode mode);
FX_API fx_status fx_compressor_set_buffer(
fx_compressor *compressor, fx_ringbuffer *inbuf, fx_ringbuffer *outbuf);
FX_API fx_status fx_compressor_step(fx_compressor *compressor);
FX_API fx_status fx_compressor_end(fx_compressor *compressor);
FX_API fx_status fx_compressor_reset(fx_compressor *compressor);
FX_API bool fx_compressor_eof(const fx_compressor *compressor);
FX_DECLS_END;
#endif

50
compress/include/fx/compress/cstream.h Normal file
View File

@@ -0,0 +1,50 @@
#ifndef FX_COMPRESS_CSTREAM_H_
#define FX_COMPRESS_CSTREAM_H_
#include <fx/core/macros.h>
#include <fx/core/stream.h>
#include <stdbool.h>
FX_DECLS_BEGIN;
enum fx_compressor_mode;
#define FX_TYPE_CSTREAM (fx_cstream_get_type())
FX_DECLARE_TYPE(fx_cstream);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_cstream)
FX_TYPE_CLASS_DECLARATION_END(fx_cstream)
FX_API fx_type fx_cstream_get_type(void);
FX_API fx_status fx_cstream_open(
fx_stream *endpoint, fx_type compressor_type, enum fx_compressor_mode mode,
fx_cstream **out);
FX_API fx_status fx_cstream_read(
fx_cstream *stream, void *buf, size_t count, size_t *nr_read);
FX_API fx_status fx_cstream_write(
fx_cstream *stream, const void *buf, size_t count, size_t *nr_written);
FX_API fx_status fx_cstream_skip(
fx_cstream *stream, size_t count, size_t *nr_skipped);
FX_API fx_status fx_cstream_reset(fx_cstream *stream);
FX_API fx_status fx_cstream_begin_compressed_section(
fx_cstream *stream, size_t *tx_uncompressed_bytes);
FX_API fx_status fx_cstream_end_compressed_section(
fx_cstream *stream, size_t *tx_compressed_bytes,
size_t *tx_uncompressed_bytes);
FX_API bool fx_cstream_in_compressed_section(const fx_cstream *stream);
FX_API fx_status fx_cstream_tx_bytes(const fx_cstream *stream, size_t *out);
FX_API fx_status fx_cstream_tx_bytes_compressed(
const fx_cstream *stream, size_t *out);
FX_API fx_status fx_cstream_tx_bytes_uncompressed(
const fx_cstream *stream, size_t *out);
FX_API fx_status fx_cstream_set_cursor_position(fx_cstream *stream, size_t pos);
FX_API fx_status fx_cstream_restore_cursor_position(fx_cstream *stream);
FX_DECLS_END;
#endif

28
compress/include/fx/compress/zstd.h Normal file
View File

@@ -0,0 +1,28 @@
#ifndef FX_COMPRESS_ZSTD_H_
#define FX_COMPRESS_ZSTD_H_
#include <fx/compress/compressor.h>
#include <fx/core/macros.h>
#include <fx/core/misc.h>
#include <fx/core/status.h>
#include <stdbool.h>
FX_DECLS_BEGIN;
#define FX_TYPE_ZSTD_COMPRESSOR (fx_zstd_compressor_get_type())
FX_DECLARE_TYPE(fx_zstd_compressor);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_zstd_compressor)
FX_TYPE_CLASS_DECLARATION_END(fx_compressor)
FX_API fx_type fx_zstd_compressor_get_type(void);
FX_API fx_status fx_zstd_compressor_get_buffer_size(
fx_compressor_mode mode, size_t *inbuf_size, size_t *outbuf_size);
FX_TYPE_DEFAULT_CONSTRUCTOR(fx_zstd_compressor, FX_TYPE_ZSTD_COMPRESSOR);
FX_DECLS_END;
#endif