Ticket #12207: 0001-12207-render-hvif-icon-files-as-png.patch

src/tools/Jamfile

@@ -111 +111 @@
 SubInclude HAIKU_TOP src tools unflatten ;
 SubInclude HAIKU_TOP src tools unzip ;
 SubInclude HAIKU_TOP src tools update_package_requires ;
+SubInclude HAIKU_TOP src tools hvif2png ;
 SubInclude HAIKU_TOP src tools vmdkimage ;
 SubInclude HAIKU_TOP src tools zip ;

new file src/tools/hvif2png/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src tools hvif2png ;
+
+UsePrivateBuildHeaders shared ;
+
+USES_BE_API on <build>hvif2png = true ;
+
+BuildPlatformMain <build>hvif2png :
+    hvif2png.cpp
+    :
+    $(HOST_LIBBE) $(HOST_LIBROOT) png 
+;

new file src/tools/hvif2png/hvif2png.cpp

@@ +1 @@
+/*
+ * Copyright 2015 Haiku, Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Andrew Lindesay
+ */
+
+
+// This command line program was created in order to be able to render
+// HVIF files and then save the resultant bitmap into a PNG image file.
+// The tool can be compiled for linux and was initially created for
+// use with the Haiku Depot Server application server so that it was
+// able to render HVIFs in the web page. 
+
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+#include <png.h>
+
+#include "InterfaceDefs.h"
+#include "Bitmap.h"
+#include "SupportDefs.h"
+#include "IconUtils.h"
+
+
+#define SIZE_HVIF_BUFFER_STEP 1024
+
+
+typedef struct h2p_hvif_buffer {
+    uint8 *buffer;
+    size_t used;
+    size_t allocated;
+} h2p_hvif_buffer;
+
+
+typedef struct h2p_parameters {
+    int size;
+    char *in_filename;
+    char *out_filename;
+} h2p_parameters;
+
+
+typedef struct h2p_state {
+    FILE *in;
+    FILE *out;
+    BBitmap *bitmap;
+    h2p_hvif_buffer hvif_buffer;
+    h2p_parameters params;
+} h2p_state;
+
+
+static int
+h2p_fprintsyntax(FILE *stream) {
+        return fprintf(stream, "syntax: hvif2png -s <size> [-i <input-file>] [-o <output-file>]\n");
+}
+
+
+static void
+h2p_close_state(h2p_state *state) {
+    if (NULL != state->hvif_buffer.buffer) {
+        free(state->hvif_buffer.buffer);
+    }
+
+    if (NULL != state->in) {
+        fclose(state->in);
+    }
+
+    if (NULL != state->out) {
+        fclose(state->out);
+    }
+}
+
+
+/*
+Returns 0 if there was some problem in opening the streams; otherwise non-zero.
+*/
+
+static int
+h2p_open_streams(h2p_state *state) {
+    if (NULL != state->params.in_filename) {
+        state->in = fopen(state->params.in_filename, "rb");
+
+        if (NULL == state->in) {
+            fprintf(stderr, "unable to open the input file; '%s'\n", state->params.in_filename);
+        }
+    } else {
+        state->in = stdin;
+    }
+
+    if (NULL != state->params.out_filename) {
+        state->out = fopen(state->params.out_filename, "wb");
+
+        if (NULL == state->out) {
+            fprintf(stderr, "unable to open the output file; '%s'\n", state->params.out_filename);
+        }
+    } else {
+        state->out = stdout;
+    }
+
+    if (NULL != state->out && NULL!=state->in) {
+        return 1; 
+    }
+
+    return 0;
+}
+
+
+static int
+h2p_write_png(BBitmap *bitmap, FILE *out) {
+
+    int result = 0;
+    png_structp png_ptr = NULL;
+    png_infop info_ptr = NULL;
+
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+
+    if (NULL == png_ptr) {
+        fprintf(stderr, "unable to setup png write data structures\n");
+    } else {
+
+        png_init_io(png_ptr, out);
+        info_ptr = png_create_info_struct(png_ptr);
+
+        if (NULL == info_ptr) {
+            fprintf(stderr, "unable to setup png info data structures\n");
+        } else {
+            BRect rect = bitmap->Bounds();
+            png_uint_32 width = (png_uint_32) rect.Width()+1;
+            png_uint_32 height = (png_uint_32) rect.Height()+1;
+
+            png_set_IHDR(
+                png_ptr, info_ptr, width, height,
+                8, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE,
+                PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+            png_set_bgr(png_ptr);
+
+            png_write_info(png_ptr, info_ptr);
+
+            uint8 *bitmap_data = (uint8 *) bitmap->Bits();
+            int32 bitmap_bytes_per_row = bitmap->BytesPerRow();
+
+            for (png_uint_32 i = 0; i < height;i++) {
+                png_write_row(png_ptr, (png_bytep) &bitmap_data[i * bitmap_bytes_per_row]);
+            }
+
+            png_write_end(png_ptr, NULL);
+
+            result = 1;
+        }
+    }
+
+    if (NULL != info_ptr) {
+        png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+    }
+
+    if (NULL != png_ptr) {
+        png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
+    }
+
+    return result;
+}
+
+
+/*
+This function will return the quantity of bytes that were read from the HVIF file or 0
+if there was a problem reading the HVIF data.
+*/
+
+static size_t
+h2p_read_hvif_input(h2p_hvif_buffer *result, FILE *in) {
+    result->buffer = (uint8 *) malloc(SIZE_HVIF_BUFFER_STEP); // hvifs are typically quite small.
+    result->allocated = SIZE_HVIF_BUFFER_STEP;
+    result->used = 0;
+
+    if (NULL == result->buffer) {
+        fprintf(stderr,"out of memory\n");
+        return 0;
+    }
+
+    while (!feof(in)) {
+        if (result->used == result->allocated) {
+            result->buffer = (uint8 *) realloc(
+                result->buffer,
+                result->allocated + SIZE_HVIF_BUFFER_STEP);
+
+            if (NULL == result->buffer) {
+                fprintf(stderr,"out of memory\n");
+                return 0;
+            }
+        }
+
+        result->used += fread(
+            &result->buffer[result->used],
+            sizeof(uint8),
+            result->allocated - result->used, in);
+
+        int err = ferror(in);
+
+        if (0 != err) {
+            fprintf(stderr, "error reading input; %s\n", strerror(err));
+            return 0;
+        }
+    }
+
+    return result->used;
+}
+
+
+/*
+Returns 0 if there was a problem reading the parameters and non-zero otherwise.
+*/
+
+static int
+h2p_parse_args(h2p_parameters *result, int argc, char *argv[]) {
+
+    for (int i = 1;i < argc;) {
+
+        if ('-' != argv[i][0]) {
+            fprintf(stderr, "was expecting a switch; found '%s'\n",argv[i]);
+            h2p_fprintsyntax(stderr);
+            return 0;
+        }
+
+        if (2 != strlen(argv[i])) {
+            fprintf(stderr, "illegal switch; '%s'\n",argv[i]);
+            h2p_fprintsyntax(stderr);
+            return 0;
+        }
+
+        switch (argv[i][1]) {
+
+            case 's':
+                
+                if (i == argc - 1) {
+                    fprintf(stderr,"the size has not been specified\n");
+                    h2p_fprintsyntax(stderr);
+                    return 0;
+                }  
+
+                result->size = atoi(argv[i + 1]);
+
+                if (result->size <= 0 || result->size > 1024) {
+                    fprintf(stderr,"bad size specified; '%s'\n", argv[i]);
+                    h2p_fprintsyntax(stderr);
+                    return 0;
+                }
+
+                i+=2;
+
+                break;
+
+            case 'i':
+
+                if (i == argc - 1) {
+                    fprintf(stderr,"the input filename has not been specified\n");
+                    h2p_fprintsyntax(stderr);
+                    return 0;
+                }
+
+                result->in_filename = argv[i + 1];
+                i+=2;
+                break;
+
+            case 'o':
+
+                if (i == argc - 1) {
+                    fprintf(stderr,"the output filename has not been specified\n");
+                    h2p_fprintsyntax(stderr);
+                    return 0;
+                }
+
+                result->out_filename = argv[i + 1];
+                i += 2;
+                break;
+
+            default:
+                fprintf(stderr, "unrecognized switch; '%s'\n", argv[i]);
+                h2p_fprintsyntax(stderr);
+                return 0;
+        }
+
+    }
+
+    if (0 == result->size) {
+        fprintf(stderr, "size has not been specified\n");
+        h2p_fprintsyntax(stderr);
+        return 0;
+    }
+ 
+    return 1;
+}
+
+
+int main(int argc, char *argv[]) {
+
+    int exit_result = 1;
+
+    if (1 == argc) {
+        h2p_fprintsyntax(stderr);
+    } else {
+
+        h2p_state state;
+        bzero(&state, sizeof(state));
+
+        if (h2p_parse_args(&(state.params), argc, argv)) {
+
+            if (h2p_open_streams(&state)) {
+
+                if (h2p_read_hvif_input(&(state.hvif_buffer), state.in) > 0) {
+
+                    // create the bitmap and then parse and render the HVIF icon data into
+                    // the bitmap.
+
+                    state.bitmap = new BBitmap(
+                        BRect(0.0, 0.0, state.params.size - 1, state.params.size - 1),
+                        B_RGBA32); // actual storage is BGRA
+
+                    status_t gvi_status = BIconUtils::GetVectorIcon(
+                        state.hvif_buffer.buffer,
+                        state.hvif_buffer.used,
+                        state.bitmap);
+
+                    if (B_OK != gvi_status) {
+                        fprintf(stderr, "the hvif data (%zdB) was not able to be parsed / rendered\n", state.hvif_buffer.used);
+                    } else {
+
+                        // write the bitmap data out again as a PNG.
+
+                        if (h2p_write_png(state.bitmap, state.out)) {
+                            exit_result = 0;
+                        }
+
+                    }
+                }
+
+            }
+        }
+
+        // clean up
+        h2p_close_state(&state);
+    }
+
+    return exit_result;
+
+}