Merge pull request #166 from sdlime/vector-tiles

Merging the raw tile pull request to master - this allows for caching non-image tiles (e.g. mvt) with MapCache.

Author: sdlime

include/mapcache.h

@@ -78,6 +78,7 @@ typedef struct mapcache_image_format_mixed mapcache_image_format_mixed;
 typedef struct mapcache_image_format_png mapcache_image_format_png;
 typedef struct mapcache_image_format_png_q mapcache_image_format_png_q;
 typedef struct mapcache_image_format_jpeg mapcache_image_format_jpeg;
+typedef struct mapcache_image_format_raw mapcache_image_format_raw;
 typedef struct mapcache_cfg mapcache_cfg;
 typedef struct mapcache_tileset mapcache_tileset;
 typedef struct mapcache_cache mapcache_cache;
@@ -663,7 +664,7 @@ MS_DLL_EXPORT int mapcache_config_services_enabled(mapcache_context *ctx, mapcac
 /** @{ */
 
 typedef enum {
-  GC_UNKNOWN, GC_PNG, GC_JPEG
+  GC_UNKNOWN, GC_PNG, GC_JPEG, GC_RAW
 } mapcache_image_format_type;
 
 typedef enum {
@@ -1434,10 +1435,16 @@ struct mapcache_image_format_mixed {
 
 mapcache_buffer* mapcache_empty_png_decode(mapcache_context *ctx, int width, int height, const unsigned char *hex_color, int *is_empty);
 
-
 mapcache_image_format* mapcache_imageio_create_mixed_format(apr_pool_t *pool,
     char *name, mapcache_image_format *transparent, mapcache_image_format *opaque, unsigned int alpha_cutoff);
 
+struct mapcache_image_format_raw {
+  mapcache_image_format format;
+};
+
+mapcache_image_format* mapcache_imageio_create_raw_format(apr_pool_t *pool, char *name, char *extension, char *mime_type); 
+int mapcache_imageio_is_raw_tileset(mapcache_tileset *tileset);
+
 /**\class mapcache_image_format_png_q
  * \brief Quantized PNG format
  * \extends mapcache_image_format_png

lib/cache_disk.c

@@ -532,14 +532,13 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac
     ctx->set_error(ctx, 500,  "failed to remove file %s: %s",filename, apr_strerror(ret,errmsg,120));
   }
 
-
 #ifdef HAVE_SYMLINK
   if(cache->symlink_blank) {
-    if(!tile->raw_image) {
+    if(tile->tileset->format->type != GC_RAW && !tile->raw_image) {
       tile->raw_image = mapcache_imageio_decode(ctx, tile->encoded_data);
       GC_CHECK_ERROR(ctx);
     }
-    if(mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
+    if(tile->tileset->format->type != GC_RAW && mapcache_image_blank_color(tile->raw_image) != MAPCACHE_FALSE) {
       char *blankname;
       int retry_count_create_symlink = 0;
       char *blankname_rel = NULL;
@@ -620,7 +619,7 @@ static void _mapcache_cache_disk_set(mapcache_context *ctx, mapcache_cache *pcac
       return;
     }
   }
-#endif /*HAVE_SYMLINK*/
+#endif /* HAVE_SYMLINK */
 
   /* go the normal way: either we haven't configured blank tile detection, or the tile was not blank */
 

lib/configuration_xml.c

@@ -520,6 +520,12 @@ void parseFormat(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
       alpha_cutoff = atoi(cur_node->txt);
     }
     format = mapcache_imageio_create_mixed_format(ctx->pool,name,transparent, opaque, alpha_cutoff);
+  } else if(!strcasecmp(type,"RAW")) {
+    char *extension=NULL;
+    char *mime_type=NULL;
+    if ((cur_node = ezxml_child(node,"extension")) != NULL) extension = apr_pstrdup(ctx->pool, cur_node->txt);
+    if ((cur_node = ezxml_child(node,"mime_type")) != NULL) mime_type = apr_pstrdup(ctx->pool, cur_node->txt);
+    format = mapcache_imageio_create_raw_format(ctx->pool,name,extension,mime_type);
   } else {
     ctx->set_error(ctx, 400, "unknown format type %s for format \"%s\"", type, name);
     return;
@@ -529,7 +535,6 @@ void parseFormat(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
     return;
   }
 
-
   mapcache_configuration_add_image_format(config,format,name);
   return;
 }
@@ -628,6 +633,7 @@ void parseTileset(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
   ezxml_t cur_node;
   char* value;
   int havewgs84bbox=0;
+
   if(config->mode == MAPCACHE_MODE_NORMAL) {
     name = (char*)ezxml_attr(node,"name");
   } else {
@@ -741,7 +747,6 @@ void parseTileset(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
       APR_ARRAY_PUSH(gridlink->intermediate_grids,mapcache_grid_link*) = intermediate_gridlink;
     }
 
-
     mapcache_grid_compute_limits(grid,extent,gridlink->grid_limits,tolerance);
 
     sTolerance = (char*)ezxml_attr(cur_node,"minzoom");
@@ -808,8 +813,6 @@ void parseTileset(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
       }
     }
 
-
-
     /* compute wgs84 bbox if it wasn't supplied already */
     if(!havewgs84bbox && !strcasecmp(grid->srs,"EPSG:4326")) {
       tileset->wgs84bbox = *extent;
@@ -893,7 +896,6 @@ void parseTileset(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
     tileset->metasize_y = values[1];
   }
 
-
   if ((cur_node = ezxml_child(node,"watermark")) != NULL) {
     if(!*cur_node->txt) {
       ctx->set_error(ctx,400, "watermark config entry empty");

lib/core.c

@@ -77,7 +77,6 @@ mapcache_http_response *mapcache_http_response_create(apr_pool_t *pool)
 
 void mapcache_prefetch_tiles(mapcache_context *ctx, mapcache_tile **tiles, int ntiles)
 {
-
   apr_thread_t **threads;
   apr_threadattr_t *thread_attrs;
   int nthreads;
@@ -99,7 +98,6 @@ void mapcache_prefetch_tiles(mapcache_context *ctx, mapcache_tile **tiles, int n
     return;
   }
 
-
   /* allocate a thread struct for each tile. Not all will be used */
   thread_tiles = (_thread_tile*)apr_pcalloc(ctx->pool,ntiles*sizeof(_thread_tile));
 #if 1 || !USE_THREADPOOL
@@ -205,7 +203,7 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r
   format = NULL;
 
 #ifdef DEBUG
-  if(req_tile->ntiles ==0) {
+  if(req_tile->ntiles == 0) {
     ctx->set_error(ctx,500,"BUG: get_tile called with 0 tiles");
     return NULL;
   }
@@ -216,7 +214,6 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r
     req_tile->tiles[0]->allow_redirect = 1;
   }
 
-
   mapcache_prefetch_tiles(ctx,req_tile->tiles,req_tile->ntiles);
   if(GC_HAS_ERROR(ctx))
     return NULL;
@@ -295,7 +292,7 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r
   }
 
   if(!response->data) {
-    /* we need to encode the raw image data*/
+    /* we need to encode the raw image data */
     if(base) {
       if(req_tile->image_request.format) {
         format = req_tile->image_request.format;
@@ -320,14 +317,28 @@ mapcache_http_response *mapcache_core_get_tile(mapcache_context *ctx, mapcache_r
       response->data = mapcache_empty_png_decode(ctx,req_tile->tiles[0]->grid_link->grid->tile_sx, req_tile->tiles[0]->grid_link->grid->tile_sy, empty,&is_empty); /* is_empty is unchanged and left to 1 */
       format = mapcache_configuration_get_image_format(ctx->config,"PNG8");
     }
+  } else {
+    /* set format, not an image type (e.g. GC_RAW) */
+    if(req_tile->image_request.format) {
+      format = req_tile->image_request.format;
+    } else {
+      format = req_tile->tiles[0]->tileset->format;
+      if(!format) {
+        format = ctx->config->default_image_format; /* this one is always defined */
+      }
+    }
   }
 
   /* compute the content-type */
-  t = mapcache_imageio_header_sniff(ctx,response->data);
-  if(t == GC_PNG)
-    apr_table_set(response->headers,"Content-Type","image/png");
-  else if(t == GC_JPEG)
-    apr_table_set(response->headers,"Content-Type","image/jpeg");
+  if(format && format->type == GC_RAW) {
+    apr_table_set(response->headers,"Content-Type",format->mime_type);
+  } else {
+    t = mapcache_imageio_header_sniff(ctx,response->data);
+    if(t == GC_PNG)
+      apr_table_set(response->headers,"Content-Type","image/png");
+    else if(t == GC_JPEG)
+      apr_table_set(response->headers,"Content-Type","image/jpeg");
+  }
 
   /* compute expiry headers */
   if(expires) {
@@ -428,14 +439,14 @@ mapcache_http_response *mapcache_core_get_map(mapcache_context *ctx, mapcache_re
   mapcache_http_response *response;
   mapcache_map *basemap = NULL;
   char *timestr;
+
 #ifdef DEBUG
   if(req_map->nmaps ==0) {
     ctx->set_error(ctx,500,"BUG: get_map called with 0 maps");
     return NULL;
   }
 #endif
 
-
   if(req_map->getmap_strategy == MAPCACHE_GETMAP_ERROR) {
     ctx->set_error(ctx, 404, "full wms support disabled");
     return NULL;
@@ -444,7 +455,6 @@ mapcache_http_response *mapcache_core_get_map(mapcache_context *ctx, mapcache_re
   format = NULL;
   response = mapcache_http_response_create(ctx->pool);
 
-
   if(req_map->getmap_strategy == MAPCACHE_GETMAP_ASSEMBLE) {
     basemap = mapcache_assemble_maps(ctx, req_map->maps, req_map->nmaps, req_map->resample_mode);
     if(GC_HAS_ERROR(ctx)) return NULL;

lib/image.c

@@ -280,12 +280,22 @@ void mapcache_image_copy_resampled_bilinear(mapcache_context *ctx, mapcache_imag
 
 void mapcache_image_metatile_split(mapcache_context *ctx, mapcache_metatile *mt)
 {
+
   if(mt->map.tileset->format) {
     /* the tileset has a format defined, we will use it to encode the data */
     mapcache_image *tileimg;
     mapcache_image *metatile;
     int i,j;
     int sx,sy;
+
+    /*
+    ** No metatile support for raw format types...
+    */
+    if(mt->map.tileset->format->type == GC_RAW) {
+      mt->tiles[0].encoded_data = mt->map.encoded_data;
+      return;
+    }
+
     if(mt->map.raw_image) {
       metatile = mt->map.raw_image;
     } else {

lib/imageio.c

@@ -58,8 +58,6 @@ mapcache_image_format_type mapcache_imageio_header_sniff(mapcache_context *ctx,
   }
 }
 
-
-
 mapcache_image* mapcache_imageio_decode(mapcache_context *ctx, mapcache_buffer *buffer)
 {
   mapcache_image_format_type type = mapcache_imageio_header_sniff(ctx,buffer);
@@ -73,7 +71,6 @@ mapcache_image* mapcache_imageio_decode(mapcache_context *ctx, mapcache_buffer *
   }
 }
 
-
 void mapcache_image_create_empty(mapcache_context *ctx, mapcache_cfg *cfg)
 {
   unsigned int color=0;

lib/imageio_raw.c

@@ -0,0 +1,61 @@
+/******************************************************************************
+ * $Id$
+ *
+ * Project:  MapServer
+ * Purpose:  MapCache tile caching support file: raw (generic) format I/O
+ * Author:   Thomas Bonfort and the MapServer team.
+ *
+ ******************************************************************************
+ * Copyright (c) 1996-2011 Regents of the University of Minnesota.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies of this Software or works derived from this Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *****************************************************************************/
+
+#include "mapcache.h"
+#include <apr_strings.h>
+
+int mapcache_imageio_is_raw_tileset(mapcache_tileset *tileset) 
+{
+  if(!tileset || !tileset->format || tileset->format->type != GC_RAW) return MAPCACHE_FALSE;
+  return MAPCACHE_TRUE;
+}
+
+static mapcache_buffer* _mapcache_imageio_raw_create_empty(mapcache_context *ctx, mapcache_image_format *format,
+							   size_t width, size_t height, unsigned int color)
+{
+  return NULL;
+}
+
+mapcache_buffer* _mapcache_imageio_raw_encode(mapcache_context *ctx, mapcache_image *img, mapcache_image_format *format)
+{
+  return NULL;
+}
+
+mapcache_image_format* mapcache_imageio_create_raw_format(apr_pool_t *pool, char *name, char *extension, char *mime_type)
+{
+  mapcache_image_format_raw *format = apr_pcalloc(pool, sizeof(mapcache_image_format_raw));
+  format->format.name = name;
+  format->format.extension = apr_pstrdup(pool, extension);
+  format->format.mime_type = apr_pstrdup(pool, mime_type);
+  format->format.metadata = apr_table_make(pool,3);
+  format->format.create_empty_image = _mapcache_imageio_raw_create_empty;
+  format->format.write = _mapcache_imageio_raw_encode;
+  format->format.type = GC_RAW;
+  return (mapcache_image_format*)format;
+}

lib/service_wms.c

@@ -264,6 +264,11 @@ void _create_capabilities_wms(mapcache_context *ctx, mapcache_request_get_capabi
     int i;
     apr_hash_this(tileindex_index,&key,&keylen,(void**)&tileset);
 
+    if(mapcache_imageio_is_raw_tileset(tileset)) {
+      tileindex_index = apr_hash_next(tileindex_index);
+      continue; /* WMS is not supported for raw layers */
+    }
+
     layerxml = ezxml_add_child(toplayer,"Layer",0);
     ezxml_set_attr(layerxml, "cascaded", "1");
     ezxml_set_attr(layerxml, "queryable", (tileset->source && tileset->source->info_formats)?"1":"0");
@@ -611,7 +616,7 @@ void _mapcache_service_wms_parse_request(mapcache_context *ctx, mapcache_service
         key = apr_strtok(layers, ",", &last); /* extract first layer */
       }
       main_tileset = mapcache_configuration_get_tileset(config,key);
-      if(!main_tileset) {
+      if(!main_tileset || mapcache_imageio_is_raw_tileset(main_tileset)) {
         errcode = 404;
         errmsg = apr_psprintf(ctx->pool,"received wms request with invalid layer %s", key);
         goto proxies;
@@ -710,7 +715,7 @@ void _mapcache_service_wms_parse_request(mapcache_context *ctx, mapcache_service
            * this step is not done for the first tileset as we have already performed it
            */
           tileset = mapcache_configuration_get_tileset(config,key);
-          if (!tileset) {
+          if (!tileset || mapcache_imageio_is_raw_tileset(tileset)) {
             errcode = 404;
             errmsg = apr_psprintf(ctx->pool,"received wms request with invalid layer %s", key);
             goto proxies;
@@ -810,7 +815,7 @@ void _mapcache_service_wms_parse_request(mapcache_context *ctx, mapcache_service
       goto proxies;
     } else {
       mapcache_tileset *tileset = mapcache_configuration_get_tileset(config,str);
-      if(!tileset) {
+      if(!tileset || mapcache_imageio_is_raw_tileset(tileset)) {
         errcode = 404;
         errmsg = apr_psprintf(ctx->pool,"received wms getfeatureinfo request with invalid layer %s", str);
         goto proxies;

lib/source.c

@@ -30,8 +30,6 @@
 #include "mapcache.h"
 #include <apr_time.h>
 
-
-
 void mapcache_source_init(mapcache_context *ctx, mapcache_source *source)
 {
   mapcache_extent tmp_extent = {-1,-1,-1,-1};
@@ -41,7 +39,6 @@ void mapcache_source_init(mapcache_context *ctx, mapcache_source *source)
   source->retry_delay = 0.1;
 }
 
-
 void mapcache_source_render_map(mapcache_context *ctx, mapcache_source *source, mapcache_map *map) {
   int i;
 #ifdef DEBUG

lib/source_wms.c

@@ -56,6 +56,7 @@ void _mapcache_source_wms_render_map(mapcache_context *ctx, mapcache_source *pso
   mapcache_source_wms *wms = (mapcache_source_wms*)psource;
   mapcache_http *http;
   apr_table_t *params = apr_table_clone(ctx->pool,wms->wms_default_params);
+
   apr_table_setn(params,"BBOX",apr_psprintf(ctx->pool,"%f,%f,%f,%f",
                  map->extent.minx,map->extent.miny,map->extent.maxx,map->extent.maxy));
   apr_table_setn(params,"WIDTH",apr_psprintf(ctx->pool,"%d",map->width));
@@ -92,7 +93,7 @@ void _mapcache_source_wms_render_map(mapcache_context *ctx, mapcache_source *pso
   mapcache_http_do_request(ctx,http,map->encoded_data,NULL,NULL);
   GC_CHECK_ERROR(ctx);
 
-  if(!mapcache_imageio_is_valid_format(ctx,map->encoded_data)) {
+  if(!mapcache_imageio_is_raw_tileset(map->tileset) && !mapcache_imageio_is_valid_format(ctx,map->encoded_data)) {
     char *returned_data = apr_pstrndup(ctx->pool,(char*)map->encoded_data->buf,map->encoded_data->size);
     ctx->set_error(ctx, 502, "wms request for tileset %s returned an unsupported format:\n%s",
                    map->tileset->name, returned_data);