chm-thumbnailer/chm-thumbnailer.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include <chm_lib.h>
   6 #include <gdk-pixbuf/gdk-pixbuf.h>
   7 #include <libxml/HTMLparser.h>
   8 #include <libxml/SAX2.h>
   9 #include <libxml/uri.h>
  10 #include <libxml/xmlstring.h>
  11
  12 static inline unsigned int get_word(const unsigned char *buffer)
  13 {
  14     unsigned int ret = 0;
  15
  16     ret |= buffer[0] << 0;
  17     ret |= buffer[1] << 8;
  18
  19     return ret;
  20 }
  21
  22 static int get_content(struct chmFile *file, const char *path,
  23         unsigned char **buffer)
  24 {
  25     struct chmUnitInfo ui;
  26
  27     if (chm_resolve_object(file, path, &ui) == CHM_RESOLVE_FAILURE)
  28         return 0;
  29     if ((*buffer = malloc(ui.length)) == NULL)
  30         return 0;
  31     if (chm_retrieve_object(file, &ui, *buffer, 0, ui.length) !=
  32             (long long)ui.length)
  33     {
  34         free(*buffer);
  35         return 0;
  36     }
  37
  38     return ui.length;
  39 }
  40
  41 static char *get_home_path(struct chmFile *file)
  42 {
  43     unsigned char *buffer;
  44     unsigned int current, type, len, total;
  45     char *path = NULL;
  46
  47     if ((total = get_content(file, "/#SYSTEM", &buffer)) == 0)
  48         return NULL;
  49     for (current = 4; current < total; current += 4 + len)
  50     {
  51         type = get_word(buffer + current);
  52         len = get_word(buffer + current + 2);
  53         if (type == 2)
  54         {
  55             if (current + 4 + len <= total && (path = malloc(len + 1)))
  56             {
  57                 path[0] = '/';
  58                 memcpy(path + 1, buffer + current + 4, len);
  59             }
  60             break;
  61         }
  62     }
  63
  64     free(buffer);
  65     return path;
  66 }
  67
  68 GdkPixbuf *get_image_from_data(unsigned char *buffer, int length)
  69 {
  70     GInputStream *input;
  71     GdkPixbuf *image;
  72
  73     input = g_memory_input_stream_new_from_data(buffer, length, NULL);
  74     image = gdk_pixbuf_new_from_stream(input, NULL, NULL);
  75     g_input_stream_close(input, NULL, NULL);
  76
  77     return image;
  78 }
  79
  80 static inline int round_div(const int x, const int y)
  81 {
  82     return (x + y / 2) / y;
  83 }
  84
  85 GdkPixbuf *scale_image(GdkPixbuf *original, int size)
  86 {
  87     int width, height;
  88     GdkInterpType type;
  89
  90     width = gdk_pixbuf_get_width(original);
  91     height = gdk_pixbuf_get_height(original);
  92     if (width < height)
  93     {
  94         width = round_div(width * size, height);
  95         type = height <= size ? GDK_INTERP_TILES : GDK_INTERP_HYPER;
  96         height = size;
  97     }
  98     else
  99     {
 100         height = round_div(height * size, width);
 101         type = width <= size ? GDK_INTERP_TILES : GDK_INTERP_HYPER;
 102         width = size;
 103     }
 104
 105     return gdk_pixbuf_scale_simple(original, width, height, type);
 106 }
 107
 108 static const double lambda = 0.993;
 109
 110 struct inner_file
 111 {
 112     struct chmFile *file;
 113     xmlChar *path;
 114     int size;
 115     double w;
 116     const xmlChar *current;
 117 };
 118
 119 static int get_content_length(struct chmFile *file, const char *path)
 120 {
 121     struct chmUnitInfo ui;
 122
 123     if (chm_resolve_object(file, path, &ui) == CHM_RESOLVE_FAILURE)
 124         return 0;
 125
 126     return ui.length;
 127 }
 128
 129 static void startelem(struct inner_file *fp, const xmlChar *name,
 130         const xmlChar **atts)
 131 {
 132     int size;
 133     xmlChar *uri = NULL;
 134
 135     if (!xmlStrcasecmp(name, (const xmlChar *)"img"))
 136     {
 137         while (*atts)
 138         {
 139             if (!xmlStrcasecmp(*atts, (const xmlChar *)"src"))
 140             {
 141                 uri = xmlBuildURI(atts[1], fp->current);
 142                 size = get_content_length(fp->file, (const char *)uri) *
 143                     fp->w;
 144                 fp->w *= lambda;
 145                 if (size > fp->size)
 146                 {
 147                     free(fp->path);
 148                     fp->path = uri;
 149                     fp->size = size;
 150                 }
 151                 else
 152                     free(uri);
 153                 break;
 154             }
 155             atts += 2;
 156         }
 157     }
 158 }
 159
 160 static char *parse_home(struct chmFile *file, unsigned char *buffer,
 161         const char *current)
 162 {
 163     struct inner_file fp = { .file = file, .path = NULL, .size = 0, .w = 1.0,
 164         .current = xmlURIEscapeStr((const xmlChar *)current, NULL) };
 165     htmlSAXHandler sax = { .startElement = (startElementSAXFunc)startelem };
 166
 167     htmlSAXParseDoc(buffer, NULL, &sax, &fp);
 168
 169     free((void *)fp.current);
 170     return (char *)fp.path;
 171 }
 172
 173 int main(const int argc, const char *argv[])
 174 {
 175     struct chmFile *file;
 176     char *homepath, *imagepath = NULL;
 177     unsigned char *buffer;
 178     int buffer_length, size;
 179     GdkPixbuf *image, *output;
 180
 181     if (argc != 4 || (size = atoi(argv[3])) <= 0)
 182         exit(EXIT_FAILURE);
 183
 184     g_type_init();
 185     if ((file = chm_open(argv[1])) == NULL)
 186         exit(EXIT_FAILURE);
 187     if ((homepath = get_home_path(file)) == NULL)
 188         exit(EXIT_FAILURE);
 189     if ((buffer_length = get_content(file, homepath, &buffer)) == 0)
 190         exit(EXIT_FAILURE);
 191     if ((image = get_image_from_data(buffer, buffer_length)) == NULL)
 192     {
 193         if ((imagepath = parse_home(file, buffer, homepath)) == NULL)
 194             exit(EXIT_FAILURE);
 195         free(buffer);
 196         if ((buffer_length = get_content(file, imagepath, &buffer)) == 0)
 197             exit(EXIT_FAILURE);
 198         if ((image = get_image_from_data(buffer, buffer_length)) == NULL)
 199             exit(EXIT_FAILURE);
 200     }
 201
 202     output = scale_image(image, size);
 203     gdk_pixbuf_save(output, argv[2], "png", NULL, "compression", "9", NULL);
 204
 205     chm_close(file);
 206     g_object_unref(image);
 207     g_object_unref(output);
 208     free(buffer);
 209     free(homepath);
 210     free(imagepath);
 211
 212     return EXIT_SUCCESS;
 213 }