added enc opt to output the JPEG in a pinned buf

refers to GH-97

Author: MartinPulec

NEWS.md

@@ -1,3 +1,8 @@
+2025-05-23 - 0.27.4
+----------
+
+- added encoder option to provide the encoded JPEG in a pinned buffer
+
 2025-05-19 - 0.27.3
 ----------
 

libgpujpeg/gpujpeg_encoder.h

@@ -1,6 +1,6 @@
 /**
  * @file
- * Copyright (c) 2011-2023, CESNET z.s.p.o
+ * Copyright (c) 2011-2025, CESNET z.s.p.o
  * Copyright (c) 2011, Silicon Genome, LLC.
  *
  * All rights reserved.
@@ -214,6 +214,16 @@ GPUJPEG_API int
 gpujpeg_encoder_suggest_restart_interval(const struct gpujpeg_image_parameters* param_image,
                                          gpujpeg_sampling_factor_t subsampling, bool interleaved, int verbose);
 
+/// buffer returned from gpujpeg_encoder_encode() should be in pinned memory
+#define GPUJPEG_ENCODER_OPT_OUT_PINNED  "enc_out_pinned"
+/**
+ * sets encoder option
+ * @retval GPUJPEG_NOERR  option was sucessfully set
+ * @retval GPUJPEG_ERROR  invalid argument passed
+ */
+GPUJPEG_API int
+gpujpeg_encoder_set_option(struct gpujpeg_encoder* encoder, const char* opt, const char* val);
+
 /**
  * Destory JPEG encoder
  *

src/gpujpeg_encoder.c

@@ -646,6 +646,24 @@ gpujpeg_encoder_set_jpeg_header(struct gpujpeg_encoder *encoder, enum gpujpeg_he
     encoder->header_type = header_type;
 }
 
+GPUJPEG_API int
+gpujpeg_encoder_set_option(struct gpujpeg_encoder* encoder, const char *opt, const char* val)
+{
+    if ( encoder == NULL || opt == NULL || val == NULL ) {
+        return GPUJPEG_ERROR;
+    }
+    if ( strcmp(opt, GPUJPEG_ENCODER_OPT_OUT_PINNED) == 0 ) {
+        if ( val[0] != '0' && val[0] != '1' ) {
+            ERROR_MSG("Unexpeceted value %s for " GPUJPEG_ENCODER_OPT_OUT_PINNED "\n", val);
+            return GPUJPEG_ERROR;
+        }
+        encoder->writer->buffer_pinned = val[0] == '1';
+        return GPUJPEG_NOERR;
+    }
+    ERROR_MSG("Invalid encoder option: %s!\n", opt);
+    return GPUJPEG_ERROR;
+}
+
 /* Documented at declaration */
 int
 gpujpeg_encoder_destroy(struct gpujpeg_encoder* encoder)

src/gpujpeg_writer.c

@@ -1,6 +1,6 @@
 /**
  * @file
- * Copyright (c) 2011-2023, CESNET z.s.p.o
+ * Copyright (c) 2011-2025, CESNET z.s.p.o
  * Copyright (c) 2011, Silicon Genome, LLC.
  *
  * All rights reserved.
@@ -53,6 +53,19 @@ gpujpeg_writer_create(void)
     return writer;
 }
 
+static void free_buffer(struct gpujpeg_writer *writer) {
+    if ( writer->buffer == NULL ) {
+        return;
+    }
+    if ( writer->buffer_pinned ) {
+        cudaFreeHost(writer->buffer);
+    }
+    else {
+        free(writer->buffer);
+    }
+    writer->buffer = NULL;
+}
+
 /* Documented at declaration */
 int
 gpujpeg_writer_init(struct gpujpeg_writer* writer, int comp_count, struct gpujpeg_image_parameters* param_image)
@@ -63,10 +76,13 @@ gpujpeg_writer_init(struct gpujpeg_writer* writer, int comp_count, struct gpujpe
 
     if (buffer_size > writer->buffer_allocated_size) {
         writer->buffer_allocated_size = 0;
-        if (writer->buffer != NULL) {
-            free(writer->buffer);
+        free_buffer(writer);
+        if ( writer->buffer_pinned ) {
+            cudaMallocHost((void**)&writer->buffer, buffer_size * sizeof(uint8_t));
+        }
+        else {
+            writer->buffer = (uint8_t*)malloc(buffer_size * sizeof(uint8_t));
         }
-        writer->buffer = (uint8_t *) malloc(buffer_size * sizeof(uint8_t));
         if (writer->buffer == NULL) {
             return -1;
         }
@@ -84,9 +100,7 @@ int
 gpujpeg_writer_destroy(struct gpujpeg_writer* writer)
 {
     assert(writer != NULL);
-    if (writer->buffer != NULL) {
-        free(writer->buffer);
-    }
+    free_buffer(writer);
     free(writer);
     return 0;
 }

src/gpujpeg_writer.h

@@ -1,6 +1,6 @@
 /**
  * @file
- * Copyright (c) 2011-2023, CESNET z.s.p.o
+ * Copyright (c) 2011-2025, CESNET z.s.p.o
  * Copyright (c) 2011, Silicon Genome, LLC.
  *
  * All rights reserved.
@@ -31,6 +31,7 @@
 #ifndef GPUJPEG_WRITER_H
 #define GPUJPEG_WRITER_H
 
+#include <stdbool.h>
 #include <stddef.h>
 #include "../libgpujpeg/gpujpeg_type.h"
 
@@ -51,6 +52,7 @@ struct gpujpeg_writer
     uint8_t* buffer_current;
     // Allocate size of output buffer.
     size_t buffer_allocated_size;
+    bool buffer_pinned; ///< buffer should be allocated in pinned memory
 
     // Segment info buffers (every buffer is placed inside another header)
     uint8_t* segment_info[GPUJPEG_MAX_SEGMENT_INFO_HEADER_COUNT];

src/main.c

@@ -283,16 +283,21 @@ struct coder_opts
     char* val;
 };
 static bool
-assign_decoder_opt(struct coder_opts* opts, char *optarg)
+assign_coder_opt(struct coder_opts* encoder_opts, struct coder_opts* decoder_opts, char* optarg)
 {
-    char *opt = optarg;
-    char *delim = strchr(optarg, '=');
+    char* opt = optarg;
+    char* delim = strchr(optarg, '=');
     if ( delim == NULL ) {
         fprintf(stderr, "No value for %s!\n", optarg);
         return false;
     }
+    if ( strncmp(optarg, "enc_", 4) != 0 && strncmp(optarg, "dec_", 4) != 0 ) {
+        fprintf(stderr, "Option should start with either enc_ or dec_, given %s!\n", optarg);
+        return false;
+    }
     *delim = '\0';
     char *val = delim + 1;
+    struct coder_opts* opts = strncmp(optarg, "enc_", 4) == 0 ? encoder_opts : decoder_opts;
     for ( int i = 0; i < CODER_OPTS_COUNT; ++i ) {
         if ( opts[i].opt == NULL ) {
             opts[i].opt = opt;
@@ -304,6 +309,18 @@ assign_decoder_opt(struct coder_opts* opts, char *optarg)
     return false;
 }
 static bool
+set_encoder_opts(struct gpujpeg_encoder* encoder, const struct coder_opts* opts)
+{
+    while ( (*opts).opt != NULL ) {
+        if ( gpujpeg_encoder_set_option(encoder, (*opts).opt, (*opts).val) != 0 ) {
+            return false;
+        }
+        opts++;
+    }
+
+    return true;
+}
+static bool
 set_decoder_opts(struct gpujpeg_decoder* decoder, const struct coder_opts* opts)
 {
     while ( (*opts).opt != NULL ) {
@@ -350,6 +367,7 @@ main(int argc, char *argv[])
     _Bool use_opengl = 0;
     bool debug = false;
     struct coder_opts decoder_options[CODER_OPTS_COUNT + 1] = {0};
+    struct coder_opts encoder_options[CODER_OPTS_COUNT + 1] = {0};
 
     // Flags
     struct options opts = {.subsampling = GPUJPEG_SUBSAMPLING_UNKNOWN,
@@ -508,7 +526,7 @@ main(int argc, char *argv[])
             debug = true;
             break;
         case 'O':
-            if ( !assign_decoder_opt(decoder_options, optarg) ) {
+            if ( !assign_coder_opt(encoder_options, decoder_options, optarg) ) {
                 return 1;
             }
             break;
@@ -608,7 +626,7 @@ main(int argc, char *argv[])
 
         // Create encoder
         struct gpujpeg_encoder* encoder = gpujpeg_encoder_create(NULL);
-        if ( encoder == NULL ) {
+        if ( encoder == NULL || !set_encoder_opts(encoder, encoder_options) ) {
             fprintf(stderr, "Failed to create encoder!\n");
             return -1;
         }