video_compress: module state changes to void *

The internal state of compression module is now simply (void *) as in other modules. The (module *)-typed vesion was actually unnecessary because except lavc, no module reads messages. Also the idea of universal API with struct module didn't make it in the end. This complements the commit 0557730 that did simlarly for external vcompress API.
2026-03-20 16:40:12 +00:00 · 2025-06-03 12:53:47 +02:00
parent 92e1c508aa
commit e056d786f1
10 changed files with 123 additions and 173 deletions
--- a/src/video_compress.cpp
+++ b/src/video_compress.cpp
@@ -6,7 +6,7 @@
 * @brief Video compress functions.
 */
 /*
- * Copyright (c) 2011-2024 CESNET z.s.p.o.
+ * Copyright (c) 2011-2025 CESNET
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -86,7 +86,7 @@ public:
        }
        ~compress_state_real();
        const video_compress_info    *funcs;            ///< handle for the driver
-        vector<struct module *> state;                  ///< driver internal states
+        vector<void*> state;                  ///< driver internal states
        string              compress_options; ///< compress options (for reconfiguration)
        volatile bool       discard_frames;   ///< this class is no longer active
 };
@@ -147,7 +147,9 @@ static void compress_process_message(struct compress_state *proxy, struct msg_ch
                        tmp_data->what = data->what;
                        strncpy(tmp_data->config_string, data->config_string,
                                        sizeof(tmp_data->config_string));
-                        struct response *resp = send_message_to_receiver(proxy->ptr->state[i],
+                        char receiver[100];
+                        snprintf(receiver, sizeof receiver, "data[%u]", i);
+                        struct response *resp = send_message(&proxy->mod, receiver,
                                        (struct message *) tmp_data);
                        /// @todo
                        /// Handle responses more intelligently (eg. aggregate).
@@ -397,7 +399,7 @@ void compress_frame(struct compress_state *proxy, shared_ptr<video_frame> frame)
 * @brief Auxiliary structure passed to worker thread.
 */
 struct compress_worker_data {
-        struct module *state;      ///< compress driver status
+        void *state;      ///< compress driver status
        shared_ptr<video_frame> frame; ///< uncompressed tile to be compressed

        compress_tile_t callback;  ///< tile compress callback
@@ -506,7 +508,7 @@ compress_state_real::~compress_state_real()
        }

        for(unsigned int i = 0; i < state.size(); ++i) {
-                module_done(state[i]);
+                funcs->done(state[i]);
        }
 }

--- a/src/video_compress.h
+++ b/src/video_compress.h
@@ -68,7 +68,7 @@

 #include "types.h"

-#define VIDEO_COMPRESS_ABI_VERSION 12
+#define VIDEO_COMPRESS_ABI_VERSION 13

 #ifdef __cplusplus
 extern "C" {
@@ -109,9 +109,12 @@ std::shared_ptr<video_frame> compress_pop(struct compress_state *);
 * @param[in] cfg    configuration string
 * @return           driver internal state
 */
-typedef struct module *(*compress_init_t)(struct module *parent,
+typedef void *(*compress_init_t)(struct module *parent,
                const char *cfg);

+/// destroys the state create by @ref compress_init_t
+typedef void (*compress_done_t)(void *state);
+
 /**
 * @brief Compresses video frame
 * 
@@ -120,7 +123,7 @@ typedef struct module *(*compress_init_t)(struct module *parent,
 *                     empty shared_ptr to fetch further compressed frames
 * @return             compressed frame, may be NULL if compression failed or no compressed frame was output
 */
-typedef  std::shared_ptr<video_frame> (*compress_frame_t)(struct module *state, std::shared_ptr<video_frame> frame);
+typedef  std::shared_ptr<video_frame> (*compress_frame_t)(void *state, std::shared_ptr<video_frame> frame);

 /**
 * @brief Compresses tile of a video frame
@@ -130,7 +133,7 @@ typedef  std::shared_ptr<video_frame> (*compress_frame_t)(struct module *state,
 *                              empty shared_ptr to fetch remaining tiles
 * @return                      compressed frame with one tile, may be NULL if compression failed or no compressed frame was output
 */
-typedef  std::shared_ptr<video_frame> (*compress_tile_t)(struct module *state, std::shared_ptr<video_frame> in_frame);
+typedef  std::shared_ptr<video_frame> (*compress_tile_t)(void *state, std::shared_ptr<video_frame> in_frame);

 /**
 * @brief Passes frame to compress module for async processing.
@@ -140,7 +143,7 @@ typedef  std::shared_ptr<video_frame> (*compress_tile_t)(struct module *state, s
 * @param[in]     state         driver internal state
 * @param[in]     in_frame      uncompressed frame or empty shared_ptr to pass a poisoned pile
 */
-typedef void (*compress_frame_async_push_t)(struct module *state, std::shared_ptr<video_frame> in_frame);
+typedef void (*compress_frame_async_push_t)(void  *state, std::shared_ptr<video_frame> in_frame);

 /**
 * @brief Fetches compressed frame passed with compress_frame_async_push()
@@ -149,7 +152,7 @@ typedef void (*compress_frame_async_push_t)(struct module *state, std::shared_pt
 * @return                      compressed frame, empty shared_ptr corresponding with poisoned
 *                              pill can be also returned
 */
-typedef  std::shared_ptr<video_frame> (*compress_frame_async_pop_t)(struct module *state);
+typedef  std::shared_ptr<video_frame> (*compress_frame_async_pop_t)(void *state);

 /**
 * @brief Passes tile to compress module for async processing.
@@ -159,7 +162,7 @@ typedef  std::shared_ptr<video_frame> (*compress_frame_async_pop_t)(struct modul
 * @param[in]     state         driver internal state
 * @param[in]     in_frame      uncompressed frame or empty shared_ptr to pass a poisoned pile
 */
-typedef void (*compress_tile_async_push_t)(struct module *state, std::shared_ptr<video_frame> in_frame);
+typedef void (*compress_tile_async_push_t)(void *state, std::shared_ptr<video_frame> in_frame);

 /**
 * @brief Fetches compressed tile passed with compress_tile_async_push()
@@ -168,7 +171,7 @@ typedef void (*compress_tile_async_push_t)(struct module *state, std::shared_ptr
 * @return                      compressed frame, empty shared_ptr corresponding with poisoned
 *                              pill can be also returned
 */
-typedef  std::shared_ptr<video_frame> (*compress_tile_async_pop_t)(struct module *state);
+typedef  std::shared_ptr<video_frame> (*compress_tile_async_pop_t)(void *state);

 struct module_option{
        std::string display_name; //Name displayed to user
@@ -213,8 +216,8 @@ struct compress_module_info{
 * 4. Async tile API - compress a tile asynchronously
 */
 struct video_compress_info {
-        const char        * name;         ///< not used
        compress_init_t     init_func;           ///< compress driver initialization function
+        compress_done_t     done;

        compress_frame_t    compress_frame_func; ///< compress function for Frame API

--- a/src/video_compress/cineform.cpp
+++ b/src/video_compress/cineform.cpp
@@ -3,7 +3,7 @@
 * @author Martin Piatka <piatka@cesnet.cz>
 *
 */
-/* Copyright (c) 2019-2023 CESNET z.s.p.o.
+/* Copyright (c) 2019-2025 CESNET
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, is permitted provided that the following conditions
@@ -49,7 +49,6 @@
 #include "debug.h"
 #include "host.h"
 #include "lib_common.h"
-#include "module.h"
 #include "tv.h"
 #include "video_compress.h"

@@ -76,8 +75,6 @@
 #define MOD_NAME "[cineform] "

 struct state_video_compress_cineform{
-        struct module module_data;
-
        std::mutex mutex;

        struct video_desc saved_desc;
@@ -107,8 +104,8 @@ struct state_video_compress_cineform{
 #endif
 };

-static void cineform_compress_done(struct module *mod){
-        struct state_video_compress_cineform *s = (struct state_video_compress_cineform *) mod->priv_data;
+static void cineform_compress_done(void *state) {
+        auto *s = (struct state_video_compress_cineform *) state;

        s->mutex.lock();

@@ -175,8 +172,9 @@ static int parse_fmt(struct state_video_compress_cineform *s, char *fmt) {
        return 0;
 }

-static struct module * cineform_compress_init(struct module *parent, const char *opts)
+static void * cineform_compress_init(struct module *parent, const char *opts)
 {
+        (void) parent;
        struct state_video_compress_cineform *s;

        s = new state_video_compress_cineform();
@@ -191,7 +189,7 @@ static struct module * cineform_compress_init(struct module *parent, const char
        free(fmt);
        if(ret != 0) {
                delete s;
-                return ret > 0 ? static_cast<module*>(INIT_NOERR) : nullptr;
+                return ret > 0 ? INIT_NOERR : nullptr;
        }

        log_msg(LOG_LEVEL_NOTICE, "[cineform] : Threads: %d.\n", s->requested_threads);
@@ -218,13 +216,7 @@ static struct module * cineform_compress_init(struct module *parent, const char
        s->started = false;
        s->stop = false;

-        module_init_default(&s->module_data);
-        s->module_data.cls = MODULE_CLASS_DATA;
-        s->module_data.priv_data = s;
-        s->module_data.deleter = cineform_compress_done;
-        module_register(&s->module_data, parent);
-
-        return &s->module_data;
+        return s;
 }

 static struct {
@@ -349,9 +341,9 @@ static video_frame *get_copy(struct state_video_compress_cineform *s, video_fram
        return ret;
 }

-static void cineform_compress_push(struct module *state, std::shared_ptr<video_frame> tx)
+static void cineform_compress_push(void *state, std::shared_ptr<video_frame> tx)
 {
-        struct state_video_compress_cineform *s = (struct state_video_compress_cineform *) state->priv_data;
+        auto *s = (struct state_video_compress_cineform *) state;

        CFHD_Error status = CFHD_ERROR_OKAY;
        std::unique_lock<std::mutex> lock(s->mutex);
@@ -435,9 +427,9 @@ static void timespec_diff(struct timespec *start, struct timespec *stop,
 }
 #endif

-static std::shared_ptr<video_frame> cineform_compress_pop(struct module *state)
+static std::shared_ptr<video_frame> cineform_compress_pop(void *state)
 {
-        struct state_video_compress_cineform *s = (struct state_video_compress_cineform *) state->priv_data;
+        auto *s = (struct state_video_compress_cineform *) state;

        std::unique_lock<std::mutex> lock(s->mutex);

@@ -531,8 +523,8 @@ static compress_module_info get_cineform_module_info(){
 }

 const struct video_compress_info cineform_info = {
-        "cineform",
        cineform_compress_init,
+        cineform_compress_done,
        NULL,
        NULL,
        NULL,
--- a/src/video_compress/cmpto_j2k.cpp
+++ b/src/video_compress/cmpto_j2k.cpp
@@ -69,7 +69,6 @@
 #include "debug.h"
 #include "host.h"
 #include "lib_common.h"
-#include "module.h"
 #include "tv.h"
 #include "utils/color_out.h"
 #include "utils/macros.h"            // for IS_KEY_PREFIX, TOSTRING
@@ -278,7 +277,6 @@ get_supported_technology(const char *name)
 }

 struct state_video_compress_j2k {
-        struct module module_data{};
        const struct cmpto_j2k_technology *tech = nullptr;
        struct cmpto_j2k_enc_ctx *context{};
        struct cmpto_j2k_enc_cfg *enc_settings{};
@@ -310,7 +308,7 @@ struct state_video_compress_j2k {

 // prototypes
 static void j2k_compressed_frame_dispose(struct video_frame *frame);
-static void j2k_compress_done(struct module *mod);
+static void j2k_compress_done(void *state);
 static void cleanup_common(struct state_video_compress_j2k *s);

 static void parallel_conv(video_frame *dst, video_frame *src){
@@ -562,7 +560,7 @@ struct custom_data {
 * pipeline. Because of that goto + start label is used.
 */
 #define HANDLE_ERROR_COMPRESS_POP do { cmpto_j2k_enc_img_destroy(img); goto start; } while (0)
-static std::shared_ptr<video_frame> j2k_compress_pop(struct module *state)
+static std::shared_ptr<video_frame> j2k_compress_pop(void *state)
 {
        auto *s = (struct state_video_compress_j2k *) state;
 start:
@@ -733,15 +731,16 @@ static void usage(bool full) {
                (var) = val; \
        } while (0)

-static struct module * j2k_compress_init(struct module *parent, const char *c_cfg)
+static void * j2k_compress_init(struct module *parent, const char *c_cfg)
 {
+        (void) parent;
        const auto *version = cmpto_j2k_enc_get_version();
        LOG(LOG_LEVEL_INFO) << MOD_NAME << "Using codec version: " << (version == nullptr ? "(unknown)" : version->name) << "\n";

        if (strcasecmp(c_cfg, "help") == 0 ||
            strcasecmp(c_cfg, "fullhelp") == 0) {
                usage(strcasecmp(c_cfg, "fullhelp") == 0);
-                return static_cast<module *>(INIT_NOERR);
+                return INIT_NOERR;
        }

        const char *req_technology = nullptr;
@@ -772,7 +771,7 @@ static struct module * j2k_compress_init(struct module *parent, const char *c_cf
                        ASSIGN_CHECK_VAL(s->thread_count, strchr(item, '=') + 1, 0);
                } else {
                        log_msg(LOG_LEVEL_ERROR, "[J2K] Wrong option: %s\n", item);
-                        j2k_compress_done((struct module *) s);
+                        j2k_compress_done(s);
                        return nullptr;
                }
        }
@@ -780,14 +779,14 @@ static struct module * j2k_compress_init(struct module *parent, const char *c_cf
        if (!s->lossless) {
                if (s->quality < 0.0 || s->quality > 1.0) {
                        LOG(LOG_LEVEL_ERROR) << "[J2K] Quality should be in interval [0-1]!\n";
-                        j2k_compress_done((struct module *) s);
+                        j2k_compress_done(s);
                        return nullptr;
                }
        }

        s->tech = get_supported_technology(req_technology);
        if (s->tech == nullptr) {
-                j2k_compress_done((struct module *) s);
+                j2k_compress_done(s);
                return nullptr;
        }
        MSG(INFO, "Using technology: %s\n", s->tech->name);
@@ -799,13 +798,7 @@ static struct module * j2k_compress_init(struct module *parent, const char *c_cf
                s->img_tile_limit = (int) s->tech->default_img_tile_limit;
        }

-        module_init_default(&s->module_data);
-        s->module_data.cls = MODULE_CLASS_DATA;
-        s->module_data.priv_data = s;
-        s->module_data.deleter = j2k_compress_done;
-        module_register(&s->module_data, parent);
-
-        return &s->module_data;
+        return s;
 }

 static void j2k_compressed_frame_dispose(struct video_frame *frame)
@@ -838,7 +831,7 @@ release_cstream_cuda(void *img_custom_data, size_t img_custom_data_size,
        } \
        return

-static void j2k_compress_push(struct module *state, std::shared_ptr<video_frame> tx)
+static void j2k_compress_push(void *state, std::shared_ptr<video_frame> tx)
 {
        struct state_video_compress_j2k *s =
                (struct state_video_compress_j2k *) state;
@@ -932,9 +925,9 @@ static void j2k_compress_push(struct module *state, std::shared_ptr<video_frame>

 }

-static void j2k_compress_done(struct module *mod)
+static void j2k_compress_done(void *state)
 {
-        auto *s = (struct state_video_compress_j2k *) mod;
+        auto *s = (struct state_video_compress_j2k *) state;
        cleanup_common(s);
        delete s;
 }
@@ -973,8 +966,8 @@ static compress_module_info get_cmpto_j2k_module_info(){
 }

 static struct video_compress_info j2k_compress_info = {
-        "cmpto_j2k",
        j2k_compress_init,
+        j2k_compress_done,
        NULL,
        NULL,
        NULL,
--- a/src/video_compress/cuda_dxt.cpp
+++ b/src/video_compress/cuda_dxt.cpp
@@ -3,7 +3,7 @@
 * @author Martin Pulec  <pulec@cesnet.cz>
 */
 /*
- * Copyright (c) 2012-2023 CESNET z. s. p. o.
+ * Copyright (c) 2012-2025 CESNET
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -45,7 +45,6 @@
 #include "debug.h"
 #include "host.h"
 #include "lib_common.h"
-#include "module.h"
 #include "pixfmt_conv.h"               // for get_decoder_from_to, decoder_t
 #include "types.h"                     // for tile, video_frame, video_desc
 #include "utils/video_frame_pool.h"
@@ -75,7 +74,6 @@ struct cuda_buffer_data_allocator : public video_frame_pool_allocator {
 };

 struct state_video_compress_cuda_dxt {
-        struct module       module_data;
        struct video_desc   saved_desc;
        char               *in_buffer;      ///< for decoded data
        char               *cuda_uyvy_buffer; ///< same as in_buffer but in device memory
@@ -88,11 +86,12 @@ struct state_video_compress_cuda_dxt {
        video_frame_pool pool{0, cuda_buffer_data_allocator()};
 };

-static void cuda_dxt_compress_done(struct module *mod);
+static void cuda_dxt_compress_done(void *state);

-struct module *cuda_dxt_compress_init(struct module *parent,
+void *cuda_dxt_compress_init(struct module *parent,
                const char *fmt)
 {
+        (void) parent;
        state_video_compress_cuda_dxt *s =
                new state_video_compress_cuda_dxt();
        s->out_codec = DXT1;
@@ -110,13 +109,7 @@ struct module *cuda_dxt_compress_init(struct module *parent,
                }
        }

-        module_init_default(&s->module_data);
-        s->module_data.cls = MODULE_CLASS_DATA;
-        s->module_data.priv_data = s;
-        s->module_data.deleter = cuda_dxt_compress_done;
-        module_register(&s->module_data, parent);
-
-        return &s->module_data;
+        return s;
 }

 static void cleanup(struct state_video_compress_cuda_dxt *s)
@@ -188,14 +181,13 @@ static bool configure_with(struct state_video_compress_cuda_dxt *s, struct video
        return true;
 }

-shared_ptr<video_frame> cuda_dxt_compress_tile(struct module *mod, shared_ptr<video_frame> tx)
+shared_ptr<video_frame> cuda_dxt_compress_tile(void *state, shared_ptr<video_frame> tx)
 {
        if (!tx) {
                return {};
        }

-        struct state_video_compress_cuda_dxt *s =
-                (struct state_video_compress_cuda_dxt *) mod->priv_data;
+        auto *s = (struct state_video_compress_cuda_dxt *) state;

        cuda_wrapper_set_device(cuda_devices[0]);

@@ -281,19 +273,16 @@ shared_ptr<video_frame> cuda_dxt_compress_tile(struct module *mod, shared_ptr<vi
        return out;
 }

-static void cuda_dxt_compress_done(struct module *mod)
+static void cuda_dxt_compress_done(void *state)
 {
-        struct state_video_compress_cuda_dxt *s =
-                (struct state_video_compress_cuda_dxt *) mod->priv_data;
-
+        auto *s = (struct state_video_compress_cuda_dxt *) state;
        cleanup(s);
-
        delete s;
 }

 const struct video_compress_info cuda_dxt_info = {
-        "cuda_dxt",
        cuda_dxt_compress_init,
+        cuda_dxt_compress_done,
        NULL,
        cuda_dxt_compress_tile,
        NULL,
--- a/src/video_compress/dxt_glsl.cpp
+++ b/src/video_compress/dxt_glsl.cpp
@@ -3,7 +3,7 @@
 * @author Martin Pulec     <pulec@cesnet.cz>
 */
 /*
- * Copyright (c) 2011-2023 CESNET, z. s. p. o.
+ * Copyright (c) 2011-2025 CESNET
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -49,7 +49,6 @@
 #include "gl_context.h"
 #include "host.h"
 #include "lib_common.h"
-#include "module.h"
 #include "pixfmt_conv.h"               // for get_decoder_from_to, decoder_t
 #include "types.h"                     // for tile, video_frame, video_desc
 #include "utils/video_frame_pool.h"
@@ -62,8 +61,6 @@ using namespace std;
 namespace {

 struct state_video_compress_rtdxt {
-        struct module module_data;
-
        struct dxt_encoder **encoder;
        int encoder_count;

@@ -81,7 +78,7 @@ struct state_video_compress_rtdxt {
 };

 static int configure_with(struct state_video_compress_rtdxt *s, struct video_frame *frame);
-static void dxt_glsl_compress_done(struct module *mod);
+static void dxt_glsl_compress_done(void *state);

 static int configure_with(struct state_video_compress_rtdxt *s, struct video_frame *frame)
 {
@@ -212,8 +209,9 @@ static int configure_with(struct state_video_compress_rtdxt *s, struct video_fra
        return true;
 }

-struct module *dxt_glsl_compress_init(struct module *parent, const char *opts)
+void *dxt_glsl_compress_init(struct module *parent, const char *opts)
 {
+        (void) parent;
        struct state_video_compress_rtdxt *s;

        if(strcmp(opts, "help") == 0) {
@@ -251,22 +249,16 @@ struct module *dxt_glsl_compress_init(struct module *parent, const char *opts)

        gl_context_make_current(NULL);

-        module_init_default(&s->module_data);
-        s->module_data.cls = MODULE_CLASS_DATA;
-        s->module_data.priv_data = s;
-        s->module_data.deleter = dxt_glsl_compress_done;
-        module_register(&s->module_data, parent);
-
-        return &s->module_data;
+        return s;
 }

-shared_ptr<video_frame> dxt_glsl_compress(struct module *mod, shared_ptr<video_frame> tx)
+shared_ptr<video_frame> dxt_glsl_compress(void *state, shared_ptr<video_frame> tx)
 {
        if (!tx) {
                return {};
        }

-        struct state_video_compress_rtdxt *s = (struct state_video_compress_rtdxt *) mod->priv_data;
+        auto *s = (struct state_video_compress_rtdxt *) state;
        int i;
        unsigned char *line1, *line2;

@@ -311,9 +303,9 @@ shared_ptr<video_frame> dxt_glsl_compress(struct module *mod, shared_ptr<video_f
        return out_frame;
 }

-static void dxt_glsl_compress_done(struct module *mod)
+static void dxt_glsl_compress_done(void *state)
 {
-        struct state_video_compress_rtdxt *s = (struct state_video_compress_rtdxt *) mod->priv_data;
+        auto *s = (struct state_video_compress_rtdxt *) state;

        if(s->encoder) {
                for(int i = 0; i < s->encoder_count; ++i) {
@@ -327,8 +319,8 @@ static void dxt_glsl_compress_done(struct module *mod)
 }

 const struct video_compress_info rtdxt_info = {
-        "RTDXT",
        dxt_glsl_compress_init,
+        dxt_glsl_compress_done,
        dxt_glsl_compress,
        NULL,
        NULL,
--- a/src/video_compress/gpujpeg.cpp
+++ b/src/video_compress/gpujpeg.cpp
@@ -3,7 +3,7 @@
 * @author Martin Pulec     <pulec@cesnet.cz>
 */
 /*
- * Copyright (c) 2011-2024 CESNET
+ * Copyright (c) 2011-2025 CESNET
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -38,6 +38,7 @@
 #include <algorithm>
 #include <cassert>
 #include <condition_variable>
+#include <cstring>
 #include <initializer_list>
 #include <libgpujpeg/gpujpeg_common.h>
 #include <libgpujpeg/gpujpeg_encoder.h>
@@ -52,7 +53,6 @@
 #include "debug.h"
 #include "host.h"
 #include "lib_common.h"
-#include "module.h"
 #include "tv.h"
 #include "utils/color_out.h"
 #include "utils/macros.h"
@@ -153,7 +153,6 @@ public:
        void push(std::shared_ptr<video_frame> in_frame);
        std::shared_ptr<video_frame> pop();

-        struct module           m_module_data;
        int                     m_restart_interval;
        int                     m_quality;
        bool                    m_force_interleaved = false;
@@ -419,8 +418,9 @@ bool state_video_compress_gpujpeg::parse_fmt(char *fmt)
 state_video_compress_gpujpeg::state_video_compress_gpujpeg(struct module *parent, const char *opts) :
        m_uses_worker_threads{}, m_in_seq{},
        m_out_seq{}, m_ended_count{},
-        m_module_data{}, m_restart_interval(UNDEF), m_quality(-1)
+        m_restart_interval(UNDEF), m_quality(-1)
 {
+        (void) parent;
        if(opts && opts[0] != '\0') {
                char *fmt = strdup(opts);
                if (!parse_fmt(fmt)) {
@@ -429,17 +429,6 @@ state_video_compress_gpujpeg::state_video_compress_gpujpeg(struct module *parent
                }
                free(fmt);
        }
-
-        module_init_default(&m_module_data);
-        m_module_data.cls = MODULE_CLASS_DATA;
-        m_module_data.priv_data = this;
-        static auto deleter = [](struct module *mod) {
-                struct state_video_compress_gpujpeg *s = (struct state_video_compress_gpujpeg *) mod->priv_data;
-                delete s;
-        };
-        m_module_data.deleter = deleter;
-
-        module_register(&m_module_data, parent);
 }

 /**
@@ -503,7 +492,8 @@ static const struct {
                ":alpha", true, ""},
 };

-struct module * gpujpeg_compress_init(struct module *parent, const char *opts)
+void *
+gpujpeg_compress_init(struct module *parent, const char *opts)
 {
        if (gpujpeg_version() >> 8 != GPUJPEG_VERSION_INT >> 8) {
                LOG(LOG_LEVEL_WARNING) << "GPUJPEG API version mismatch! (compiled: " <<
@@ -527,19 +517,19 @@ struct module * gpujpeg_compress_init(struct module *parent, const char *opts)
                }

                col() << "\n";
-                return static_cast<module*>(INIT_NOERR);
+                return INIT_NOERR;
        }
        if (opts && strcmp(opts, "check") == 0) {
                auto device_info = gpujpeg_get_devices_info();
-                return device_info.device_count == 0 ? nullptr : static_cast<module*>(INIT_NOERR);
+                return device_info.device_count == 0 ? nullptr : INIT_NOERR;
        }
        if (opts && strcmp(opts, "list_devices") == 0) {
                printf("CUDA devices:\n");
 #if GPUJPEG_VERSION_INT >= GPUJPEG_MK_VERSION_INT(0, 16, 0)
-                return gpujpeg_print_devices_info() == 0 ? static_cast<module*>(INIT_NOERR) : nullptr;
+                return gpujpeg_print_devices_info() == 0 ? INIT_NOERR : nullptr;
 #else
                gpujpeg_print_devices_info();
-                return static_cast<module*>(INIT_NOERR);
+                return INIT_NOERR;
 #endif
        }

@@ -549,7 +539,7 @@ struct module * gpujpeg_compress_init(struct module *parent, const char *opts)
                return NULL;
        }

-        return &s->m_module_data;
+        return s;
 }

 /**
@@ -746,17 +736,23 @@ static compress_module_info get_gpujpeg_module_info(){
        return module_info;
 }

-static auto gpujpeg_compress_push(struct module *mod, std::shared_ptr<video_frame> in_frame) {
-        static_cast<struct state_video_compress_gpujpeg *>(mod->priv_data)->push(std::move(in_frame));
+static auto gpujpeg_compress_push(void *state, std::shared_ptr<video_frame> in_frame) {
+        static_cast<struct state_video_compress_gpujpeg *>(state)->push(std::move(in_frame));
 }

-static auto gpujpeg_compress_pull (struct module *mod) {
-        return static_cast<struct state_video_compress_gpujpeg *>(mod->priv_data)->pop();
+static auto gpujpeg_compress_pull (void *state) {
+        return static_cast<struct state_video_compress_gpujpeg *>(state)->pop();
+}
+
+static void
+gpujpeg_compress_done(void *state)
+{
+        delete (struct state_video_compress_gpujpeg *) state;
 }

 const struct video_compress_info gpujpeg_info = {
-        "GPUJPEG",
        gpujpeg_compress_init,
+        gpujpeg_compress_done,
        NULL,
        NULL,
        gpujpeg_compress_push,
@@ -772,8 +768,8 @@ static auto gpujpeg_compress_init_deprecated(struct module *parent, const char *
 }

 const struct video_compress_info deprecated_jpeg_info = {
-        "JPEG",
        gpujpeg_compress_init_deprecated,
+        gpujpeg_compress_done,
        NULL,
        NULL,
        gpujpeg_compress_push,
--- a/src/video_compress/libavcodec.cpp
+++ b/src/video_compress/libavcodec.cpp
@@ -3,7 +3,7 @@
 * @author Martin Pulec     <pulec@cesnet.cz>
 */
 /*
- * Copyright (c) 2013-2024 CESNET, z. s. p. o.
+ * Copyright (c) 2013-2025 CESNET
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -176,7 +176,7 @@ typedef struct {
 } codec_params_t;

 static void libavcodec_check_messages(struct state_video_compress_libav *s);
-static void libavcodec_compress_done(struct module *mod);
+static void libavcodec_compress_done(void *state);
 static void setparam_default(AVCodecContext *, struct setparam_param *);
 static void setparam_h264_h265_av1(AVCodecContext *, struct setparam_param *);
 static void setparam_jpeg(AVCodecContext *, struct setparam_param *);
@@ -269,7 +269,6 @@ struct state_video_compress_libav {
                module_init_default(&module_data);
                module_data.cls = MODULE_CLASS_DATA;
                module_data.priv_data = this;
-                module_data.deleter = libavcodec_compress_done;
                module_register(&module_data, parent);
        }
        ~state_video_compress_libav() {
@@ -688,7 +687,7 @@ static compress_module_info get_libavcodec_module_info(){
 ADD_TO_PARAM("keep-pixfmt",
                "* keep-pixfmt\n"
                "  Signalize input pixel format to receiver and try\n");
-struct module * libavcodec_compress_init(struct module *parent, const char *opts)
+void* libavcodec_compress_init(struct module *parent, const char *opts)
 {
        ug_set_av_logging();
 #if LIBAVCODEC_VERSION_INT <= AV_VERSION_INT(58, 9, 100)
@@ -708,8 +707,8 @@ struct module * libavcodec_compress_init(struct module *parent, const char *opts
        }
        free(fmt);
        if (ret != 0) {
-                module_done(&s->module_data);
-                return ret > 0 ? static_cast<module*>(INIT_NOERR) : NULL;
+                libavcodec_compress_done(s);
+                return ret > 0 ? INIT_NOERR : NULL;
        }

        return &s->module_data;
@@ -1530,9 +1529,9 @@ receive_packet(state_video_compress_libav *s)
        return out_vf_from_pkt(s, s->pkt);
 }

-static shared_ptr<video_frame> libavcodec_compress_tile(struct module *mod, shared_ptr<video_frame> tx)
+static shared_ptr<video_frame> libavcodec_compress_tile(void *state, shared_ptr<video_frame> tx)
 {
-        auto *s = (state_video_compress_libav *) mod->priv_data;
+        auto *s = (state_video_compress_libav *) state;
        list<shared_ptr<void>> cleanup_callbacks; // at function exit handlers

        libavcodec_check_messages(s);
@@ -1636,9 +1635,9 @@ static void cleanup(struct state_video_compress_libav *s)
 #endif //HAVE_SWSCALE
 }

-static void libavcodec_compress_done(struct module *mod)
+static void libavcodec_compress_done(void *state)
 {
-        struct state_video_compress_libav *s = (struct state_video_compress_libav *) mod->priv_data;
+        auto *s = (struct state_video_compress_libav *) state;

        cleanup(s);

@@ -2312,8 +2311,8 @@ static void libavcodec_check_messages(struct state_video_compress_libav *s)
 }

 const struct video_compress_info libavcodec_info = {
-        "libavcodec",
        libavcodec_compress_init,
+        libavcodec_compress_done,
        NULL,
        libavcodec_compress_tile,
        NULL,
@@ -2324,8 +2323,8 @@ const struct video_compress_info libavcodec_info = {
 };

 const struct video_compress_info lavc_info = {
-        "lavc",
        libavcodec_compress_init,
+        libavcodec_compress_done,
        nullptr,
        libavcodec_compress_tile,
        nullptr,
--- a/src/video_compress/none.cpp
+++ b/src/video_compress/none.cpp
@@ -3,7 +3,7 @@
 * @author Martin Pulec     <pulec@cesnet.cz>
 */
 /*
- * Copyright (c) 2012-2023 CESNET, z. s. p. o.
+ * Copyright (c) 2012-2025 CESNET
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -46,7 +46,6 @@
 #include "debug.h"
 #include "host.h"
 #include "lib_common.h"
-#include "module.h"
 #include "video_codec.h"
 #include "video_compress.h"
 #include "video_frame.h"
@@ -55,41 +54,34 @@ namespace {

 #define MAGIC 0x45bb3321

-static void none_compress_done(struct module *mod);
+static void none_compress_done(void *state);

 struct state_video_compress_none {
-        struct module module_data;
-
        uint32_t magic;
 };

-struct module * none_compress_init(struct module *parent, const char *)
+void* none_compress_init(module *parent, const char *)
 {
-        struct state_video_compress_none *s;
-        
-        s = (struct state_video_compress_none *) malloc(sizeof(struct state_video_compress_none));
+        (void) parent;
+        auto *s = (struct state_video_compress_none *) malloc(
+            sizeof(struct state_video_compress_none));
        s->magic = MAGIC;
-        module_init_default(&s->module_data);
-        s->module_data.cls = MODULE_CLASS_DATA;
-        s->module_data.priv_data = s;
-        s->module_data.deleter = none_compress_done;
-        module_register(&s->module_data, parent);

-        return &s->module_data;
+        return s;
 }

-std::shared_ptr<video_frame> none_compress(struct module *mod, std::shared_ptr<video_frame> tx)
+std::shared_ptr<video_frame> none_compress(void *state, std::shared_ptr<video_frame> tx)
 {
-        struct state_video_compress_none *s = (struct state_video_compress_none *) mod->priv_data;
+        auto *s = (struct state_video_compress_none *) state;

        assert(s->magic == MAGIC);

        return tx;
 }

-static void none_compress_done(struct module *mod)
+static void none_compress_done(void  *state)
 {
-        struct state_video_compress_none *s = (struct state_video_compress_none *) mod->priv_data;
+        auto *s = (struct state_video_compress_none *) state;

        assert(s->magic == MAGIC);

@@ -97,8 +89,8 @@ static void none_compress_done(struct module *mod)
 }

 const struct video_compress_info none_info = {
-        "none",
        none_compress_init,
+        none_compress_done,
        none_compress,
        NULL,
        NULL,
--- a/src/video_compress/uyvy.cpp
+++ b/src/video_compress/uyvy.cpp
@@ -3,7 +3,7 @@
 * @author Martin Pulec     <pulec@cesnet.cz>
 */
 /*
- * Copyright (c) 2013-2023 CESNET, z. s. p. o.
+ * Copyright (c) 2013-2025 CESNET
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
@@ -43,7 +43,6 @@
 #include "debug.h"
 #include "host.h"
 #include "lib_common.h"
-#include "module.h"
 #include "utils/video_frame_pool.h"
 #include "video_compress.h"
 #include "video.h"
@@ -107,8 +106,6 @@ static const char fp_display_rgba_to_yuv422_legacy[] =


 struct state_video_compress_uyvy {
-        struct module module_data;
-
        unsigned int configured:1;
        struct video_desc saved_desc;

@@ -126,13 +123,14 @@ struct state_video_compress_uyvy {
 };

 int uyvy_configure_with(struct state_video_compress_uyvy *s, struct video_frame *tx);
-static void uyvy_compress_done(struct module *mod);
+static void uyvy_compress_done(void *mod);

-struct module * uyvy_compress_init(struct module *parent, const char *)
+void *
+uyvy_compress_init(struct module *parent, const char *)
 {
-        struct state_video_compress_uyvy *s;
-
-        s = (struct state_video_compress_uyvy *) malloc(sizeof(struct state_video_compress_uyvy));
+        (void) parent;
+        auto *s = (struct state_video_compress_uyvy *) malloc(
+            sizeof(struct state_video_compress_uyvy));

        if(!init_gl_context(&s->context, GL_CONTEXT_LEGACY))
                abort();
@@ -156,13 +154,7 @@ struct module * uyvy_compress_init(struct module *parent, const char *)

        s->pool = new video_frame_pool();

-        module_init_default(&s->module_data);
-        s->module_data.cls = MODULE_CLASS_DATA;
-        s->module_data.priv_data = s;
-        s->module_data.deleter = uyvy_compress_done;
-        module_register(&s->module_data, parent);
-
-        return &s->module_data;
+        return s;
 }

 int uyvy_configure_with(struct state_video_compress_uyvy *s, struct video_frame *tx)
@@ -227,12 +219,12 @@ int uyvy_configure_with(struct state_video_compress_uyvy *s, struct video_frame
        return true;
 }

-shared_ptr<video_frame> uyvy_compress(struct module *mod, shared_ptr<video_frame> tx)
+shared_ptr<video_frame> uyvy_compress(void *state, shared_ptr<video_frame> tx)
 {
        if (!tx) {
                return {};
        }
-        struct state_video_compress_uyvy *s = (struct state_video_compress_uyvy *) mod->priv_data;
+        auto *s = (struct state_video_compress_uyvy *) state;

        gl_context_make_current(&s->context);

@@ -286,9 +278,9 @@ shared_ptr<video_frame> uyvy_compress(struct module *mod, shared_ptr<video_frame
        return out;
 }

-static void uyvy_compress_done(struct module *mod)
+static void uyvy_compress_done(void *state)
 {
-        struct state_video_compress_uyvy *s = (struct state_video_compress_uyvy *) mod->priv_data;
+        auto *s = (struct state_video_compress_uyvy *) state;

        glDeleteFramebuffers(1, &s->fbo);
        glDeleteTextures(1, &s->texture_rgba);
@@ -301,8 +293,8 @@ static void uyvy_compress_done(struct module *mod)
 }

 const struct video_compress_info uyvy_info = {
-        "UYVY",
        uyvy_compress_init,
+        uyvy_compress_done,
        uyvy_compress,
        NULL,
        NULL,