encoder channel remap: improvements

- improved doxygen docu
- store remapped channel count explicitly, so eg. "0000" will be allowed
- as a consequence, refuse remapping if remapped channel count doesn't
equal image pixel format channel count

Author: MartinPulec

libgpujpeg/gpujpeg_encoder.h

@@ -235,11 +235,15 @@ gpujpeg_encoder_suggest_restart_interval(const struct gpujpeg_image_parameters*
 #define GPUJPEG_ENC_OPT_FLIPPED_BOOL "enc_opt_flipped"
 
 /**
- * remaps input channel order, format "XYZ" or "XYZW" where the letters stand for input channel
- * indices (0-indexed) mapped to output position; so eg. remapping from ARGB to RGBA will be
- * "1230". If number of channes doesn't equal the length of the string, the characters are invalid
- * or out-of bound, the behavior is undefined. set to "" (empty string) to revert this setting.
- * Placeholder'Z' or 'F' can be used instead of numbers to fill out channel with zeros or all-ones.
+ * remap input channel order
+ *
+ * Format is "XYZ" or "XYZW" where the letters stand for input channel indices (0-indexed) mapped to output position;
+ * so eg. for remapping from ARGB to RGBA the option value will be "1230".
+ *
+ * The number of image channes must equal the length of the string. Set to "" (empty string) to revert this setting.
+ * Letters 'Z' or 'F' can be used instead of indices to fill given output channel with zeros or all-ones.
+ *
+ * Currently, the remapping is implemented for GPUJPEG_4444_U8_P0123 only.
  */
 #define GPUJPEG_ENC_OPT_CHANNEL_REMAP "enc_opt_channel_remap"
 

src/gpujpeg_encoder.c

@@ -664,7 +664,8 @@ enc_opt_set_channel_remap(struct gpujpeg_encoder* encoder, const char* val)
         printf("\t\"1230\" or \"123F\" to map ARGB to RGBA\n");
         return GPUJPEG_ERROR;
     }
-    if ( strlen(val) > GPUJPEG_MAX_COMPONENT_COUNT ) {
+    const int mapped_count = strlen(val);
+    if ( mapped_count > GPUJPEG_MAX_COMPONENT_COUNT ) {
         ERROR_MSG("Mapping for more than %d channels specified!\n", GPUJPEG_MAX_COMPONENT_COUNT);
         return GPUJPEG_ERROR;
     }
@@ -678,13 +679,15 @@ enc_opt_set_channel_remap(struct gpujpeg_encoder* encoder, const char* val)
         else if ( *val == 'Z' ) {
             src_chan = 5;
         }
-        else if ( src_chan >= GPUJPEG_MAX_COMPONENT_COUNT ) {
-            ERROR_MSG("Invalid channel %c for " GPUJPEG_ENC_OPT_CHANNEL_REMAP "!\n", *val);
+        else if ( src_chan < 0 || src_chan >= mapped_count ) {
+            ERROR_MSG("Invalid channel index %c for " GPUJPEG_ENC_OPT_CHANNEL_REMAP " (mapping %d channels)!\n", *val,
+                      mapped_count);
             return GPUJPEG_ERROR;
         }
         encoder->coder.preprocessor.channel_remap |= src_chan << 12;
         val++;
     }
+    encoder->coder.preprocessor.channel_remap |= mapped_count << 24;
     return GPUJPEG_NOERR;
 }
 

src/gpujpeg_preprocessor.cu

@@ -521,13 +521,23 @@ static int
 channel_remap(struct gpujpeg_encoder* encoder)
 {
     struct gpujpeg_coder* coder = &encoder->coder;
+
+    const unsigned comp_count = gpujpeg_pixel_format_get_comp_count(coder->param_image.pixel_format);
+    const unsigned mapped_count = coder->preprocessor.channel_remap >> 24;
+    if (comp_count != mapped_count) {
+        ERROR_MSG("Wrong channel remapping given, given %u channels but pixel format has %u!\n", mapped_count,
+                  comp_count);
+        return -1;
+    }
+    const unsigned mapping = coder->preprocessor.channel_remap & 0xFFFF;
+
     if ( coder->param_image.pixel_format == GPUJPEG_4444_U8_P0123 ) {
         dim3 block(16, 16);
         int width = coder->param_image.width;
         int height = coder->param_image.height;
         dim3 grid((width + block.x - 1) / block.x, (height + block.y - 1) / block.y);
         channel_remap_kernel<GPUJPEG_4444_U8_P0123><<<grid, block, 0, encoder->stream>>>(
-            encoder->coder.d_data_raw, width, height, coder->preprocessor.channel_remap);
+            encoder->coder.d_data_raw, width, height, mapping);
     }
     else {
         ERROR_MSG("Pixel format %s currently unsupported for channel remap!\n",

src/gpujpeg_preprocessor.h

@@ -71,6 +71,7 @@ struct gpujpeg_preprocessor
     void* kernel;       // function poitner
     bool input_flipped;         ///< [preprocess only] input buf is flipped
     unsigned int channel_remap; ///< remap input channels if != 0; currently preproecss only
+                                ///< format: count_8b | 00000000 | idx0_4b | idx1_4b | idx2_4b | idx3_4b
     struct gpujpeg_preprocessor_data data;
 };