testing mapnik vector datasource

src/org/oscim/database/MapDatabaseFactory.java

@@ -45,7 +45,8 @@ public final class MapDatabaseFactory {
 			case TEST_READER:
 				return new org.oscim.database.test.MapDatabase();
 			case PBMAP_READER:
-				return new org.oscim.database.pbmap.MapDatabase();
+				//return new org.oscim.database.pbmap.MapDatabase();
+				return new org.oscim.database.mapnik.MapDatabase();
 			case OSCIMAP_READER:
 				return new org.oscim.database.oscimap.MapDatabase();
 			default:

src/org/oscim/database/mapnik/LwHttp.java

@@ -0,0 +1,397 @@
+/*
+ * Copyright 2013 Hannes Janetzek
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.oscim.database.mapnik;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.MalformedURLException;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.net.URL;
+import java.util.zip.InflaterInputStream;
+
+import org.oscim.core.Tile;
+
+import android.os.SystemClock;
+import android.util.Log;
+
+public class LwHttp {
+	private static final String TAG = LwHttp.class.getName();
+	private final static int BUFFER_SIZE = 65536;
+
+	//
+	byte[] buffer = new byte[BUFFER_SIZE];
+
+	// position in buffer
+	int bufferPos;
+
+	// bytes available in buffer
+	int bufferFill;
+
+	// offset of buffer in message
+	private int mBufferOffset;
+
+	private String mHost;
+	private int mPort;
+	private InputStream mInputStream;
+
+	private int mMaxReq = 0;
+	private Socket mSocket;
+	private OutputStream mCommandStream;
+	private BufferedInputStream mResponseStream;
+	long mLastRequest = 0;
+	private SocketAddress mSockAddr;
+
+	//private final static byte[] RESPONSE_HTTP_OK = "HTTP/1.1 200 OK".getBytes();
+	private final static byte[] RESPONSE_HTTP_OK = "200 OK".getBytes();
+	private final static byte[] RESPONSE_CONTENT_LEN = "Content-Length: ".getBytes();
+	private final static int RESPONSE_EXPECTED_LIVES = 100;
+	private final static int RESPONSE_EXPECTED_TIMEOUT = 10000;
+
+	private byte[] REQUEST_GET_START;
+	private byte[] REQUEST_GET_END;
+
+	private byte[] mRequestBuffer;
+
+	boolean setServer(String urlString) {
+		urlString = "http://d1s11ojcu7opje.cloudfront.net/dev/764e0b8d";
+
+		URL url;
+		try {
+			url = new URL(urlString);
+		} catch (MalformedURLException e) {
+
+			e.printStackTrace();
+			return false;
+			//return new OpenResult("invalid url: " + options.get("url"));
+		}
+
+		int port = url.getPort();
+		if (port < 0)
+			port = 80;
+
+		String host = url.getHost();
+		String path = url.getPath();
+		Log.d(TAG, "open database: " + host + " " + port + " " + path);
+
+		REQUEST_GET_START = ("GET " + path).getBytes();
+		REQUEST_GET_END = (".vector.pbf HTTP/1.1\n" +
+				"User-Agent: Wget/1.13.4 (linux-gnu)\n" +
+				"Accept: */*\n" +
+				"Host: " + host + "\n" +
+				"Connection: Keep-Alive\n\n").getBytes();
+
+		mHost = host;
+		mPort = port;
+
+		mRequestBuffer = new byte[1024];
+		System.arraycopy(REQUEST_GET_START, 0,
+				mRequestBuffer, 0, REQUEST_GET_START.length);
+
+		return true;
+	}
+
+	void close() {
+		if (mSocket != null) {
+			try {
+				mSocket.close();
+			} catch (IOException e) {
+				e.printStackTrace();
+			} finally {
+				mSocket = null;
+			}
+		}
+	}
+
+	int readHeader() throws IOException {
+
+		InputStream is = mResponseStream;
+		mResponseStream.mark(1 << 16);
+
+		byte[] buf = buffer;
+		boolean first = true;
+		int read = 0;
+		int pos = 0;
+		int end = 0;
+		int len = 0;
+
+		int contentLength = 0;
+
+		// header cannot be larger than BUFFER_SIZE for this to work
+		for (; pos < read || (len = is.read(buf, read, BUFFER_SIZE - read)) >= 0; len = 0) {
+			read += len;
+			while (end < read && (buf[end] != '\n'))
+				end++;
+
+			if (buf[end] == '\n') {
+				if (first) {
+					// check only for OK
+					first = false;
+					if (!compareBytes(buf, pos + 9, end, RESPONSE_HTTP_OK, 6)){
+						String line = new String(buf, pos, end - pos - 1);
+						Log.d(TAG, ">" + line + "< ");
+						return -1;
+					}
+				} else if (end - pos == 1) {
+					// check empty line (header end)
+					end += 1;
+					break;
+				}
+				else {
+					// parse Content-Length, TODO just encode this with message
+					for (int i = 0; pos + i < end - 1; i++) {
+						if (i < 16) {
+							if (buf[pos + i] == RESPONSE_CONTENT_LEN[i])
+								continue;
+
+							break;
+						}
+
+						// read int value
+						contentLength = contentLength * 10 + (buf[pos + i]) - '0';
+					}
+				}
+				//String line = new String(buf, pos, end - pos - 1);
+				//Log.d(TAG, ">" + line + "< ");
+
+				pos += (end - pos) + 1;
+				end = pos;
+			}
+		}
+
+		// back to start of content
+		mResponseStream.reset();
+		mResponseStream.mark(0);
+		mResponseStream.skip(end);
+
+		// start of content
+		bufferPos = 0;
+		mBufferOffset = 0;
+
+		// buffer fill
+		bufferFill = 0;
+
+		// decode zlib compressed content
+		mInputStream = new InflaterInputStream(mResponseStream);
+
+		return 1;
+	}
+
+	boolean sendRequest(Tile tile) throws IOException {
+
+		bufferFill = 0;
+		bufferPos = 0;
+		//mReadPos = 0;
+
+		if (mSocket != null && ((mMaxReq-- <= 0)
+				|| (SystemClock.elapsedRealtime() - mLastRequest
+				> RESPONSE_EXPECTED_TIMEOUT))) {
+			try {
+				mSocket.close();
+			} catch (IOException e) {
+
+			}
+
+			// Log.d(TAG, "not alive  - recreate connection " + mMaxReq);
+			mSocket = null;
+		}
+
+		if (mSocket == null) {
+			lwHttpConnect();
+			// we know our server
+			mMaxReq = RESPONSE_EXPECTED_LIVES;
+			// Log.d(TAG, "create connection");
+		} else {
+			// should not be needed
+			int avail = mResponseStream.available();
+			if (avail > 0) {
+				Log.d(TAG, "Consume left-over bytes: " + avail);
+				mResponseStream.read(buffer, 0, avail);
+			}
+		}
+
+		byte[] request = mRequestBuffer;
+		int pos = REQUEST_GET_START.length;
+
+		request[pos++] = '/';
+		request[pos++] = pos2hex(tile.tileX);
+		request[pos++] = pos2hex(tile.tileY);
+		request[pos++] = '/';
+		pos = writeInt(tile.zoomLevel, pos, request);
+		request[pos++] = '/';
+		pos = writeInt(tile.tileX, pos, request);
+		request[pos++] = '/';
+		pos = writeInt(tile.tileY, pos, request);
+
+		int len = REQUEST_GET_END.length;
+		System.arraycopy(REQUEST_GET_END, 0, request, pos, len);
+		len += pos;
+
+		//Log.d(TAG, "request " + new String(request,0,len));
+		// this does the same but with a few more allocations:
+		// byte[] request = String.format(REQUEST,
+		// Integer.valueOf(tile.zoomLevel),
+		// Integer.valueOf(tile.tileX), Integer.valueOf(tile.tileY)).getBytes();
+
+		try {
+			mCommandStream.write(request, 0, len);
+			mCommandStream.flush();
+			return true;
+		} catch (IOException e) {
+			Log.d(TAG, "recreate connection");
+		}
+
+		lwHttpConnect();
+
+		mCommandStream.write(request, 0, len);
+		mCommandStream.flush();
+
+		return true;
+	}
+
+	private final static byte[] hexTable = {
+			'0', '1', '2', '3', '4', '5', '6', '7',
+			'8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+	private static byte pos2hex(int pos){
+		return hexTable[(pos % 16)];
+	}
+
+	private boolean lwHttpConnect() throws IOException {
+		if (mSockAddr == null)
+			mSockAddr = new InetSocketAddress(mHost, mPort);
+
+		mSocket = new Socket();
+		mSocket.connect(mSockAddr, 30000);
+		mSocket.setTcpNoDelay(true);
+
+		mCommandStream = mSocket.getOutputStream();
+		mResponseStream = new BufferedInputStream(mSocket.getInputStream());
+
+		return true;
+	}
+
+	// write (positive) integer as char sequence to buffer
+	private static int writeInt(int val, int pos, byte[] buf) {
+		if (val == 0) {
+			buf[pos] = '0';
+			return pos + 1;
+		}
+
+		int i = 0;
+		for (int n = val; n > 0; n = n / 10, i++)
+			buf[pos + i] = (byte) ('0' + n % 10);
+
+		// reverse bytes
+		for (int j = pos, end = pos + i - 1, mid = pos + i / 2; j < mid; j++, end--) {
+			byte tmp = buf[j];
+			buf[j] = buf[end];
+			buf[end] = tmp;
+		}
+
+		return pos + i;
+	}
+
+	private static boolean compareBytes(byte[] buffer, int position, int available,
+			byte[] string, int length) {
+
+		if (available - position < length)
+			return false;
+
+		for (int i = 0; i < length; i++)
+			if (buffer[position + i] != string[i])
+				return false;
+
+		return true;
+	}
+
+	static int decodeInt(byte[] buffer, int offset) {
+		return buffer[offset] << 24 | (buffer[offset + 1] & 0xff) << 16
+				| (buffer[offset + 2] & 0xff) << 8
+				| (buffer[offset + 3] & 0xff);
+	}
+
+	public boolean hasData() {
+		try {
+			return readBuffer(1);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	public int position() {
+		return mBufferOffset + bufferPos;
+	}
+
+	public boolean readBuffer(int size) throws IOException {
+		// check if buffer already contains the request bytes
+		if (bufferPos + size < bufferFill)
+			return true;
+
+		// check if inputstream is read to the end
+		//if (mReadPos == mReadEnd)
+		//	return;
+
+		int maxSize = buffer.length;
+
+		if (size > maxSize) {
+			Log.d(TAG, "increase read buffer to " + size + " bytes");
+			maxSize = size;
+			byte[] tmp = new byte[maxSize];
+			bufferFill -= bufferPos;
+			System.arraycopy(buffer, bufferPos, tmp, 0, bufferFill);
+			mBufferOffset += bufferPos;
+			bufferPos = 0;
+			buffer = tmp;
+		}
+
+		if (bufferFill == bufferPos) {
+			mBufferOffset += bufferPos;
+			bufferPos = 0;
+			bufferFill = 0;
+		} else if (bufferPos + size > maxSize) {
+			// copy bytes left to the beginning of buffer
+			bufferFill -= bufferPos;
+			System.arraycopy(buffer, bufferPos, buffer, 0, bufferFill);
+			mBufferOffset += bufferPos;
+			bufferPos = 0;
+		}
+
+		int max = maxSize - bufferFill;
+
+		while ((bufferFill - bufferPos) < size && max > 0) {
+
+			max = maxSize - bufferFill;
+
+			// read until requested size is available in buffer
+			int len = mInputStream.read(buffer, bufferFill, max);
+
+			if (len < 0) {
+				// finished reading, mark end
+				buffer[bufferFill] = 0;
+				return false;
+			}
+
+			bufferFill += len;
+		}
+		return true;
+	}
+
+}

src/org/oscim/database/mapnik/MapDatabase.java

@@ -0,0 +1,899 @@
+/*
+ * Copyright 2013
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.oscim.database.mapnik;
+
+import java.io.IOException;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+
+import org.oscim.core.BoundingBox;
+import org.oscim.core.GeoPoint;
+import org.oscim.core.GeometryBuffer.GeometryType;
+import org.oscim.core.MapElement;
+import org.oscim.core.Tag;
+import org.oscim.core.Tile;
+import org.oscim.database.IMapDatabase;
+import org.oscim.database.IMapDatabaseCallback;
+import org.oscim.database.MapInfo;
+import org.oscim.database.MapOptions;
+import org.oscim.layers.tile.MapTile;
+import org.oscim.utils.UTF8Decoder;
+import org.oscim.utils.pool.Inlist;
+import org.oscim.utils.pool.Pool;
+
+import android.os.SystemClock;
+import android.util.Log;
+
+public class MapDatabase implements IMapDatabase {
+	private static final String TAG = MapDatabase.class.getName();
+
+	private static final MapInfo mMapInfo =
+			new MapInfo(new BoundingBox(-180, -90, 180, 90),
+					new Byte((byte) 4), new GeoPoint(53.11, 8.85),
+					null, 0, 0, 0, "de", "comment", "author",
+					new int[] { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }
+			);
+
+	private final static float REF_TILE_SIZE = 4096.0f;
+
+	// 'open' state
+	private boolean mOpen = false;
+
+	private IMapDatabaseCallback mMapGenerator;
+	private float mScaleFactor;
+	private MapTile mTile;
+
+	private LwHttp lwHttp;
+
+	private final UTF8Decoder mStringDecoder;
+
+	//private final MapElement mElem;
+
+	public MapDatabase() {
+		mStringDecoder = new UTF8Decoder();
+		//mElem = new MapElement();
+	}
+
+	@Override
+	public QueryResult executeQuery(MapTile tile, IMapDatabaseCallback mapDatabaseCallback) {
+		QueryResult result = QueryResult.SUCCESS;
+
+		mTile = tile;
+
+		mMapGenerator = mapDatabaseCallback;
+
+		// scale coordinates to tile size
+		mScaleFactor = REF_TILE_SIZE / Tile.SIZE;
+
+		try {
+
+			if (lwHttp.sendRequest(tile) && lwHttp.readHeader() >= 0) {
+				decode();
+			} else {
+				Log.d(TAG, tile + " Network Error");
+				result = QueryResult.FAILED;
+			}
+		} catch (SocketException ex) {
+			Log.d(TAG, tile + " Socket exception: " + ex.getMessage());
+			result = QueryResult.FAILED;
+		} catch (SocketTimeoutException ex) {
+			Log.d(TAG, tile + " Socket Timeout exception: " + ex.getMessage());
+			result = QueryResult.FAILED;
+		} catch (UnknownHostException ex) {
+			Log.d(TAG, tile + " no network");
+			result = QueryResult.FAILED;
+		} catch (Exception ex) {
+			ex.printStackTrace();
+			result = QueryResult.FAILED;
+		}
+
+		lwHttp.mLastRequest = SystemClock.elapsedRealtime();
+
+		if (result != QueryResult.SUCCESS) {
+			lwHttp.close();
+		}
+		Log.d(TAG, ">>> " + result + " >>> " + mTile);
+		return result;
+	}
+
+	@Override
+	public MapInfo getMapInfo() {
+		return mMapInfo;
+	}
+
+	@Override
+	public boolean isOpen() {
+		return mOpen;
+	}
+
+	@Override
+	public OpenResult open(MapOptions options) {
+		if (mOpen)
+			return OpenResult.SUCCESS;
+
+		if (options == null || !options.containsKey("url"))
+			return new OpenResult("options missing");
+
+		lwHttp = new LwHttp();
+
+		if (!lwHttp.setServer(options.get("url"))) {
+			return new OpenResult("invalid url: " + options.get("url"));
+		}
+
+		mOpen = true;
+		initDecorder();
+
+		return OpenResult.SUCCESS;
+	}
+
+	@Override
+	public void close() {
+		mOpen = false;
+		lwHttp.close();
+	}
+
+	@Override
+	public String getMapProjection() {
+		return null;
+	}
+
+	@Override
+	public void cancel() {
+	}
+
+	private static final int TAG_TILE_LAYERS = 3;
+
+	private static final int TAG_LAYER_VERSION = 15;
+	private static final int TAG_LAYER_NAME = 1;
+	private static final int TAG_LAYER_FEATURES = 2;
+	private static final int TAG_LAYER_KEYS = 3;
+	private static final int TAG_LAYER_VALUES = 4;
+	private static final int TAG_LAYER_EXTENT = 5;
+
+	private static final int TAG_FEATURE_ID = 1;
+	private static final int TAG_FEATURE_TAGS = 2;
+	private static final int TAG_FEATURE_TYPE = 3;
+	private static final int TAG_FEATURE_GEOMETRY = 4;
+
+	private static final int TAG_VALUE_STRING = 1;
+	private static final int TAG_VALUE_FLOAT = 2;
+	private static final int TAG_VALUE_DOUBLE = 3;
+	private static final int TAG_VALUE_LONG = 4;
+	private static final int TAG_VALUE_UINT = 5;
+	private static final int TAG_VALUE_SINT = 6;
+	private static final int TAG_VALUE_BOOL = 7;
+
+	private static final int TAG_GEOM_UNKNOWN = 0;
+	private static final int TAG_GEOM_POINT = 1;
+	private static final int TAG_GEOM_LINE = 2;
+	private static final int TAG_GEOM_POLYGON = 3;
+
+	//rivate final short[] mTmpKeys = new short[100];
+	//private final Tag[] mTmpTags = new Tag[20];
+	//private Tag[][] mElementTags;
+
+	private short[] mTmpTags = new short[1024];
+
+	//private final short[] mPrevTags = new short[1024];
+
+	private void initDecorder() {
+		// reusable tag set
+		//		Tag[][] tags = new Tag[10][];
+		//		for (int i = 0; i < 10; i++)
+		//			tags[i] = new Tag[i + 1];
+		//mElementTags = tags;
+	}
+
+	private boolean decode() throws IOException {
+
+		int val;
+
+		while (lwHttp.hasData() && (val = decodeVarint32()) > 0) {
+			// read tag and wire type
+			int tag = (val >> 3);
+
+			switch (tag) {
+				case TAG_TILE_LAYERS:
+					decodeLayer();
+					break;
+
+				default:
+					Log.d(TAG, mTile + " invalid type for tile: " + tag);
+					return false;
+			}
+		}
+		return true;
+	}
+
+	private boolean decodeLayer() throws IOException {
+
+		int version = 0;
+		int extent = 4096;
+
+		int bytes = decodeVarint32();
+
+		ArrayList<String> keys = new ArrayList<String>();
+		ArrayList<String> values = new ArrayList<String>();
+
+		String name = null;
+		int numFeatures = 0;
+		ArrayList<Feature> features = new ArrayList<MapDatabase.Feature>();
+
+		int end = lwHttp.position() + bytes;
+		while (lwHttp.position() < end) {
+			// read tag and wire type
+			int val = decodeVarint32();
+			if (val == 0)
+				break;
+
+			int tag = (val >> 3);
+
+			switch (tag) {
+				case TAG_LAYER_KEYS:
+					keys.add(decodeString());
+					break;
+
+				case TAG_LAYER_VALUES:
+					values.add(decodeValue());
+					break;
+
+				case TAG_LAYER_FEATURES:
+					numFeatures++;
+					decodeFeature(features);
+					break;
+
+				case TAG_LAYER_VERSION:
+					version = decodeVarint32();
+					break;
+
+				case TAG_LAYER_NAME:
+					name = decodeString();
+					break;
+
+				case TAG_LAYER_EXTENT:
+					extent = decodeVarint32();
+					break;
+
+				default:
+					Log.d(TAG, mTile + " invalid type for layer: " + tag);
+					break;
+			}
+
+		}
+		boolean isRoad = "road".equals(name);
+		boolean isBridge = "bridge".equals(name);
+		boolean isTunnel = "tunnel".equals(name);
+		boolean isBuilding = "building".equals(name);
+		boolean isLanduse = "landuse".equals(name);
+		boolean isWater = "water".equals(name);
+
+		Tag layerTag = new Tag(name, Tag.VALUE_YES);
+
+		if (numFeatures == 0)
+			return true;
+
+		for (Feature f : features) {
+			int addTags = 0;
+			if (isBuilding || isWater)
+				addTags = 1;
+
+			Tag[] tags = new Tag[f.numTags + addTags];
+
+			if (isBuilding)
+				tags[tags.length - 1] = BUILDING_TAG;
+			if (isWater)
+				tags[tags.length - 1] = WATER_TAG;
+
+			if (tags.length == 0)
+				continue;
+
+			for (int j = 0; j < (f.numTags << 1); j += 2) {
+
+				String key = keys.get(f.tags[j]);
+				String val = values.get(f.tags[j + 1]);
+
+				Tag tag = null;
+				if ("class".equals(key)) {
+					if (isRoad || isTunnel || isBridge) {
+						if ("street".equals(val))
+							tag = HIGHWAY_STREET_TAG;
+						else if ("main".equals(val))
+							tag = HIGHWAY_MAIN_TAG;
+						else if ("major".equals(val))
+							tag = HIGHWAY_MAJOR_TAG;
+						else if ("major_rail".equals(val))
+							tag = HIGHWAY_RAIL_TAG;
+						else
+							tag = new Tag(Tag.TAG_KEY_HIGHWAY, val);
+
+					} else if (isLanduse)
+						tag = new Tag(Tag.TAG_KEY_LANDUSE, val);
+				}
+				if (tag == null)
+					tag = new Tag(key, val);
+
+				tags[j >> 1] = tag;
+			}
+
+			f.elem.set(tags, 5);
+			mMapGenerator.renderElement(f.elem);
+			mFeaturePool.release(f);
+		}
+
+		return true;
+	}
+
+	private final Pool<Feature> mFeaturePool = new Pool<Feature>() {
+		int count;
+
+		@Override
+		protected Feature createItem() {
+			count++;
+			return new Feature();
+		}
+
+		@Override
+		protected boolean clearItem(Feature item) {
+			if (count > 50) {
+				count--;
+				return false;
+			}
+
+			item.elem.tags = null;
+			item.elem.clear();
+			item.tags = null;
+			item.type = 0;
+			item.numTags = 0;
+
+			return true;
+		}
+	};
+
+	private final static Tag WATER_TAG = new Tag("natural", "water");
+	private final static Tag BUILDING_TAG = new Tag("building", "yes");
+	private final static Tag HIGHWAY_MAIN_TAG = new Tag("highway", "secondary");
+	private final static Tag HIGHWAY_MAJOR_TAG = new Tag("highway", "primary");
+	private final static Tag HIGHWAY_STREET_TAG = new Tag("highway", "residential");
+	private final static Tag HIGHWAY_RAIL_TAG = new Tag("railway", "rail");
+
+	//private final Tag[] mFallbackTag = new Tag[] { new Tag("debug", "way") };
+
+	//	private int mClipped;
+
+	static class Feature extends Inlist<Feature> {
+		short[] tags;
+		int numTags;
+		int type;
+
+		final MapElement elem;
+
+		Feature() {
+			elem = new MapElement();
+		}
+
+		boolean match(short otherTags[], int otherNumTags, int otherType) {
+			if (numTags != otherNumTags)
+				return false;
+
+			if (type != otherType)
+				return false;
+
+			for (int i = 0; i < numTags << 1; i++) {
+				if (tags[i] != otherTags[i])
+					return false;
+			}
+			return true;
+		}
+
+	}
+
+	private void decodeFeature(ArrayList<Feature> features) throws IOException {
+		int bytes = decodeVarint32();
+		int end = lwHttp.position() + bytes;
+
+		int type = 0;
+		long id;
+
+		lastX = 0;
+		lastY = 0;
+
+		mTmpTags[0] = -1;
+
+		Feature curFeature = null;
+		int numTags = 0;
+
+		//Log.d(TAG, "start feature");
+		while (lwHttp.position() < end) {
+			// read tag and wire type
+			int val = decodeVarint32();
+			if (val == 0)
+				break;
+
+			int tag = (val >>> 3);
+
+			switch (tag) {
+				case TAG_FEATURE_ID:
+					id = decodeVarint32();
+					break;
+
+				case TAG_FEATURE_TAGS:
+					mTmpTags = decodeShortArray(mTmpTags);
+
+					for (; numTags < mTmpTags.length && mTmpTags[numTags] >= 0;)
+						numTags += 2;
+
+					numTags >>= 1;
+
+					break;
+
+				case TAG_FEATURE_TYPE:
+					type = decodeVarint32();
+
+					//Log.d(TAG, "got type " + type);
+
+					break;
+
+				case TAG_FEATURE_GEOMETRY:
+
+					for (Feature f : features) {
+						if (f.match(mTmpTags, numTags, type)) {
+							curFeature = f;
+							break;
+						}
+					}
+
+					if (curFeature == null) {
+						curFeature = mFeaturePool.get();
+						curFeature.tags = new short[numTags << 1];
+						System.arraycopy(mTmpTags, 0, curFeature.tags, 0, numTags << 1);
+						curFeature.numTags = numTags;
+						curFeature.type = type;
+
+						features.add(curFeature);
+					}
+
+					decodeCoordinates(type, curFeature);
+					break;
+
+				default:
+					Log.d(TAG, mTile + " invalid type for feature: " + tag);
+					break;
+			}
+		}
+	}
+
+	private final static int CLOSE_PATH = 0x07;
+	private final static int MOVE_TO = 0x01;
+	//private final static int LINE_TO = 0x02;
+
+	private int lastX, lastY;
+	private final int pixel = 7;
+
+	private int decodeCoordinates(int type, Feature feature) throws IOException {
+		int bytes = decodeVarint32();
+		lwHttp.readBuffer(bytes);
+
+		if (feature == null) {
+			lwHttp.bufferPos += bytes;
+			return 0;
+		}
+
+		MapElement elem = feature.elem;
+
+		boolean isPoint = false;
+		boolean isPoly = false;
+		boolean isLine = false;
+
+		if (type == TAG_GEOM_LINE) {
+			elem.startLine();
+			isLine = true;
+		}
+		else if (type == TAG_GEOM_POLYGON) {
+			elem.startPolygon();
+			isPoly = true;
+		} else if (type == TAG_GEOM_POINT) {
+			isPoint = true;
+			elem.startPoints();
+		} else if (type == TAG_GEOM_UNKNOWN)
+			elem.startPoints();
+
+		int cnt = 0;
+
+		boolean even = true;
+
+		float scale = mScaleFactor;
+
+		byte[] buf = lwHttp.buffer;
+		int pos = lwHttp.bufferPos;
+		int end = pos + bytes;
+		int val;
+		int curX = 0;
+		int curY = 0;
+		int prevX = 0;
+		int prevY = 0;
+
+		int cmd = 0;
+		int num = 0;
+		boolean first = true;
+		boolean lastClip = false;
+
+		boolean isOuter = true;
+
+		int xmin = Integer.MAX_VALUE, xmax = Integer.MIN_VALUE;
+		int ymin = Integer.MAX_VALUE, ymax = Integer.MIN_VALUE;
+
+		while (pos < end) {
+			if (buf[pos] >= 0) {
+				val = buf[pos++];
+
+			} else if (buf[pos + 1] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| buf[pos++] << 7;
+
+			} else if (buf[pos + 2] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++]) << 14;
+
+			} else if (buf[pos + 3] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++] & 0x7f) << 14
+						| (buf[pos++]) << 21;
+
+			} else {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++] & 0x7f) << 14
+						| (buf[pos++] & 0x7f) << 21
+						| (buf[pos]) << 28;
+
+				int max = pos + VARINT_LIMIT;
+				while (pos < max)
+					if (buf[pos++] >= 0)
+						break;
+
+				if (pos == max)
+					throw new IOException("malformed VarInt32 in " + mTile);
+			}
+
+			if (num == 0) {
+				num = val >>> 3;
+				cmd = val & 0x07;
+
+				if (isLine && lastClip) {
+					elem.addPoint(curX / scale, curY / scale);
+					lastClip = false;
+				}
+
+				if (cmd == CLOSE_PATH) {
+					num = 0;
+					continue;
+				}
+				if (first) {
+					first = false;
+					continue;
+				}
+				if (cmd == MOVE_TO) {
+					if (type == TAG_GEOM_LINE)
+						elem.startLine();
+					else if (type == TAG_GEOM_POLYGON) {
+						isOuter = false;
+						elem.startHole();
+					}
+				}
+			} else {
+				// zigzag decoding
+				int s = ((val >>> 1) ^ -(val & 1));
+
+				if (even) {
+					even = false;
+					curX = lastX = lastX + s;
+				} else {
+					even = true;
+
+					curY = lastY = lastY + s;
+
+					int dx = (curX - prevX);
+					int dy = (curY - prevY);
+
+					if ((isPoint || cmd == MOVE_TO)
+							|| (dx > pixel || dx < -pixel)
+							|| (dy > pixel || dy < -pixel)
+							// dont clip at tile boundaries
+							|| (curX <= 0 || curX >= 4095)
+							|| (curY <= 0 || curY >= 4095)) {
+						prevX = curX;
+						prevY = curY;
+						elem.addPoint(curX / scale, curY / scale);
+						lastClip = false;
+
+						if (isPoly) {
+							if (curX < xmin)
+								xmin = curX;
+							if (curX > xmax)
+								xmax = curX;
+
+							if (curY < ymin)
+								ymin = curY;
+							if (curY > ymax)
+								ymax = curY;
+
+						}
+
+					} else {
+						lastClip = true;
+					}
+
+					num--;
+					cnt++;
+				}
+			}
+		}
+
+		if (isPoly && isOuter && !testBBox(xmax - xmin, ymax - ymin)) {
+			//Log.d(TAG, "skip small poly "+ elem.indexPos + " > "
+			// +  (xmax - xmin) * (ymax - ymin));
+			elem.pointPos -= elem.index[elem.indexPos];
+			if (elem.indexPos > 0) {
+				elem.indexPos -= 3;
+				elem.index[elem.indexPos + 1] = -1;
+			} else {
+				elem.type = GeometryType.NONE;
+			}
+
+			lwHttp.bufferPos += bytes;
+
+			return 0;
+		}
+
+		if (isLine && lastClip)
+			elem.addPoint(curX / scale, curY / scale);
+
+		lwHttp.bufferPos = pos;
+
+		return cnt;
+	}
+
+	private static boolean testBBox(int dx, int dy) {
+		return dx * dy > 64 * 64;
+	}
+
+	private String decodeValue() throws IOException {
+		int bytes = decodeVarint32();
+
+		String value = null;
+
+		int end = lwHttp.position() + bytes;
+
+		while (lwHttp.position() < end) {
+			// read tag and wire type
+			int val = decodeVarint32();
+			if (val == 0)
+				break;
+
+			int tag = (val >> 3);
+
+			switch (tag) {
+				case TAG_VALUE_STRING:
+					value = decodeString();
+					break;
+
+				case TAG_VALUE_UINT:
+					value = String.valueOf(decodeVarint32());
+					break;
+
+				case TAG_VALUE_SINT:
+					value = String.valueOf(decodeVarint32());
+					break;
+
+				case TAG_VALUE_LONG:
+					value = String.valueOf(decodeVarint32());
+					break;
+
+				case TAG_VALUE_FLOAT:
+					value = String.valueOf(decodeFloat());
+					break;
+
+				case TAG_VALUE_DOUBLE:
+					value = String.valueOf(decodeDouble());
+					break;
+
+				case TAG_VALUE_BOOL:
+					value = decodeBool() ? "yes" : "no";
+					break;
+				default:
+					break;
+			}
+
+		}
+		return value;
+	}
+
+	private final static int VARINT_LIMIT = 7;
+	private final static int VARINT_MAX = 10;
+
+	private short[] decodeShortArray(short[] array) throws IOException {
+		int bytes = decodeVarint32();
+		int arrayLength = array.length;
+
+		lwHttp.readBuffer(bytes);
+		int cnt = 0;
+
+		byte[] buf = lwHttp.buffer;
+		int pos = lwHttp.bufferPos;
+		int end = pos + bytes;
+		int val;
+
+		while (pos < end) {
+			if (buf[pos] >= 0) {
+				val = buf[pos++];
+			} else if (buf[pos + 1] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| buf[pos++] << 7;
+			} else if (buf[pos + 2] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++]) << 14;
+			} else if (buf[pos + 3] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++] & 0x7f) << 14
+						| (buf[pos++]) << 21;
+			} else {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++] & 0x7f) << 14
+						| (buf[pos++] & 0x7f) << 21
+						| (buf[pos]) << 28;
+
+				int max = pos + VARINT_LIMIT;
+				while (pos < max)
+					if (buf[pos++] >= 0)
+						break;
+
+				if (pos == max)
+					throw new IOException("malformed VarInt32 in " + mTile);
+			}
+
+			if (arrayLength <= cnt) {
+				arrayLength = cnt + 16;
+				short[] tmp = array;
+				array = new short[arrayLength];
+				System.arraycopy(tmp, 0, array, 0, cnt);
+			}
+
+			array[cnt++] = (short) val;
+		}
+
+		lwHttp.bufferPos = pos;
+
+		if (arrayLength > cnt)
+			array[cnt] = -1;
+
+		return array;
+	}
+
+	private int decodeVarint32() throws IOException {
+		if (lwHttp.bufferPos + VARINT_MAX > lwHttp.bufferFill)
+			lwHttp.readBuffer(4096);
+
+		byte[] buf = lwHttp.buffer;
+		int pos = lwHttp.bufferPos;
+		int val;
+
+		if (buf[pos] >= 0) {
+			val = buf[pos++];
+		} else {
+
+			if (buf[pos + 1] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++]) << 7;
+
+			} else if (buf[pos + 2] >= 0) {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++]) << 14;
+
+			} else if (buf[pos + 3] >= 0) {
+				val = (buf[pos++] & 0x7f
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++] & 0x7f) << 14
+						| (buf[pos++]) << 21);
+			} else {
+				val = (buf[pos++] & 0x7f)
+						| (buf[pos++] & 0x7f) << 7
+						| (buf[pos++] & 0x7f) << 14
+						| (buf[pos++] & 0x7f) << 21
+						| (buf[pos]) << 28;
+
+				// 'Discard upper 32 bits'
+				int max = pos + VARINT_LIMIT;
+				while (pos < max)
+					if (buf[pos++] >= 0)
+						break;
+
+				if (pos == max)
+					throw new IOException("malformed VarInt32 in " + mTile);
+			}
+		}
+
+		lwHttp.bufferPos = pos;
+
+		return val;
+	}
+
+	private float decodeFloat() throws IOException {
+		if (lwHttp.bufferPos + 4 > lwHttp.bufferFill)
+			lwHttp.readBuffer(4096);
+
+		byte[] buf = lwHttp.buffer;
+		int pos = lwHttp.bufferPos;
+
+		int val = (buf[pos++] & 0xFF
+				| (buf[pos++] & 0xFF) << 8
+				| (buf[pos++] & 0xFF) << 16
+				| (buf[pos++] & 0xFF) << 24);
+
+		lwHttp.bufferPos += 4;
+
+		return Float.intBitsToFloat(val);
+	}
+
+	private double decodeDouble() throws IOException {
+		if (lwHttp.bufferPos + 8 > lwHttp.bufferFill)
+			lwHttp.readBuffer(4096);
+
+		byte[] buf = lwHttp.buffer;
+		int pos = lwHttp.bufferPos;
+
+		long val = (buf[pos++] & 0xFF
+				| (buf[pos++] & 0xFF) << 8
+				| (buf[pos++] & 0xFF) << 16
+				| (buf[pos++] & 0xFF) << 24
+				| (buf[pos++] & 0xFF) << 32
+				| (buf[pos++] & 0xFF) << 40
+				| (buf[pos++] & 0xFF) << 48
+				| (buf[pos++] & 0xFF) << 56);
+
+		lwHttp.bufferPos += 8;
+
+		return Double.longBitsToDouble(val);
+	}
+
+	private boolean decodeBool() throws IOException {
+		if (lwHttp.bufferPos + 1 > lwHttp.bufferFill)
+			lwHttp.readBuffer(4096);
+
+		boolean val = lwHttp.buffer[lwHttp.bufferPos++] != 0;
+
+		return val;
+	}
+
+	private String decodeString() throws IOException {
+		final int size = decodeVarint32();
+		lwHttp.readBuffer(size);
+		final String result = mStringDecoder.decode(lwHttp.buffer, lwHttp.bufferPos, size);
+
+		//Log.d(TAG, "string:  " + result);
+
+		lwHttp.bufferPos += size;
+
+		return result;
+
+	}
+}