allocate CPU quant data buffer just if needed

In the most eligible scenario, when using restart intervals, the Huffman
coder is run on GPU and the data are used from there without need to
copy to CPU memory. The CPU buffer is using pinned memory , which:

1. occupies needlessly some RAM space (non-swapable, so physically
occupied) - 2 x PIX_COUNT x CHANNELS B
2. the allocation of pinned memory takes some amount of time - for 4K
24-bit picture it is about 5-10 ms (Linux) depending on the HW but when
encoding single large image it can be significant

Author: MartinPulec

src/gpujpeg_common.c

@@ -562,6 +562,21 @@ reset_timers(struct gpujpeg_coder* coder)
     GPUJPEG_CUSTOM_TIMER_RESET(coder->duration_in_gpu);
 }
 
+int
+gpujpeg_coder_allocate_cpu_huffman_buf(struct gpujpeg_coder * coder) {
+    cudaMallocHost((void**)&coder->data_quantized, coder->data_size * sizeof(int16_t));
+    gpujpeg_cuda_check_error("Coder quantized data host allocation", return -1);
+
+    int16_t* comp_data_quantized = coder->data_quantized;
+    for ( int comp = 0; comp < coder->param.comp_count; comp++ ) {
+        struct gpujpeg_component* component = &coder->component[comp];
+        component->data_quantized = comp_data_quantized;
+        comp_data_quantized += (size_t) component->data_width * component->data_height;
+    }
+
+    return 0;
+}
+
 size_t
 gpujpeg_coder_init_image(struct gpujpeg_coder * coder, const struct gpujpeg_parameters * param, const struct gpujpeg_image_parameters * param_image, cudaStream_t stream)
 {
@@ -853,13 +868,12 @@ gpujpeg_coder_init_image(struct gpujpeg_coder * coder, const struct gpujpeg_para
         cudaMalloc((void**)&coder->d_data, (coder->data_size + idct_overhead) * sizeof(uint8_t));
         gpujpeg_cuda_check_error("Coder data device allocation", return 0);
 
-        // (Re)allocated DCT and quantizer data in host memory
-        if (coder->data_quantized != NULL) {
+        // Deallocate DCT and quantizer data in host memory, alloc just if needed
+        // (gpujpeg_coder_allocate_cpu_huff_data())
+        if ( coder->data_quantized != NULL ) {
             cudaFreeHost(coder->data_quantized);
             coder->data_quantized = NULL;
         }
-        cudaMallocHost((void**)&coder->data_quantized, coder->data_size * sizeof(int16_t));
-        gpujpeg_cuda_check_error("Coder quantized data host allocation", return 0);
 
         // (Re)allocated DCT and quantizer data in device memory
         if (coder->d_data_quantized != NULL) {
@@ -882,17 +896,14 @@ gpujpeg_coder_init_image(struct gpujpeg_coder * coder, const struct gpujpeg_para
     // Set data buffer to color components
     uint8_t* d_comp_data = coder->d_data;
     int16_t* d_comp_data_quantized = coder->d_data_quantized;
-    int16_t* comp_data_quantized = coder->data_quantized;
     unsigned int data_quantized_index = 0;
     for ( int comp = 0; comp < coder->param.comp_count; comp++ ) {
         struct gpujpeg_component* component = &coder->component[comp];
         component->d_data = d_comp_data;
         component->d_data_quantized = d_comp_data_quantized;
         component->data_quantized_index = data_quantized_index;
-        component->data_quantized = comp_data_quantized;
         d_comp_data += component->data_width * component->data_height;
         d_comp_data_quantized += component->data_width * component->data_height;
-        comp_data_quantized += component->data_width * component->data_height;
         data_quantized_index += component->data_width * component->data_height;
     }
 

src/gpujpeg_common_internal.h

@@ -393,6 +393,15 @@ gpujpeg_coder_init(struct gpujpeg_coder* coder);
 size_t
 gpujpeg_coder_init_image(struct gpujpeg_coder * coder, const struct gpujpeg_parameters * param, const struct gpujpeg_image_parameters * param_image, cudaStream_t stream);
 
+/**
+ * @brief allocate buffers for CPU Huffman coder
+ * Separated from gpujpeg_coder_init_image() - called only if needed, which is not normally so (using GPU Huffman
+ * coder if restart intervals are not disabled).
+ * @return 0 if succeeds, otherwise nonzero
+ */
+int
+gpujpeg_coder_allocate_cpu_huffman_buf(struct gpujpeg_coder * coder);
+
 /**
  * Returns duration statistics for last coded image
  */

src/gpujpeg_decoder.c

@@ -265,6 +265,11 @@ gpujpeg_decoder_decode(struct gpujpeg_decoder* decoder, uint8_t* image, size_t i
     // Perform huffman decoding on CPU (when there are not enough segments to saturate GPU)
     if (coder->segment_count < 32 || unsupp_gpu_huffman_params) {
         GPUJPEG_CUSTOM_TIMER_START(coder->duration_huffman_coder, coder->param.perf_stats, decoder->stream, return -1);
+        if (coder->data_quantized == NULL) {
+            if (gpujpeg_coder_allocate_cpu_huffman_buf(coder) != 0) {
+                return -1;
+            }
+        }
         if (0 != gpujpeg_huffman_cpu_decoder_decode(decoder)) {
             fprintf(stderr, "[GPUJPEG] [Error] Huffman decoder failed!\n");
             return -1;

src/gpujpeg_encoder.c

@@ -502,6 +502,11 @@ gpujpeg_encoder_encode(struct gpujpeg_encoder* encoder, const struct gpujpeg_par
     // Perform huffman coding on CPU (when restart interval is not set)
     if ( coder->param.restart_interval == 0 ) {
         GPUJPEG_CUSTOM_TIMER_START(coder->duration_memory_from, coder->param.perf_stats, encoder->stream, return -1);
+        if (coder->data_quantized == NULL) {
+            if (gpujpeg_coder_allocate_cpu_huffman_buf(coder) != 0) {
+                return -1;
+            }
+        }
         // Copy quantized data from device memory to cpu memory
         cudaMemcpyAsync(coder->data_quantized, coder->d_data_quantized, coder->data_size * sizeof(int16_t), cudaMemcpyDeviceToHost, encoder->stream);