list() ;
/**
* Get the filesystem / archive parameters. Things that are stored in
* the header.
*
* @return The filesystem parameters.
*/
public FileSystemParam fsparam();
/**
* Reconfigure the filesystem with the given parameters.
* Only some parameters can be changed and the may only be changeable
* at certain points in the construction of a file system for example.
* @param param The new parameters.
* @throws IllegalStateException If the changes cannot be made (for example
* if the file system is already written).
*/
public void fsparam(FileSystemParam param);
/**
* Sync with the underlying file. All unwritten data is written out to
* the underlying file.
* @throws IOException If an error occurs during the write.
*/
public void sync() throws IOException;
/**
* Close the filesystem. Any saved data is flushed out. It is better
* to explicitly sync the data out first, to be sure that it has worked.
*/
void close();
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/fs/package.html 0000644 0000764 0000764 00000000571 10637204532 021727 0 ustar steve steve
Interfaces for accessing the filesystem
These are the way that application code should access the
filesystem parts of the code.
The main interface is {@link uk.me.parabola.imgfmt.fs.FileSystem} which contains
all the operations that can be performed on the system.
See also
The Garmin img project
mkgmap-r3660/src/uk/me/parabola/imgfmt/fs/ImgChannel.java 0000644 0000764 0000764 00000002431 11503736442 022316 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 02-Dec-2006
*/
package uk.me.parabola.imgfmt.fs;
import java.nio.channels.ByteChannel;
/**
* An extension of ByteChannel that allows us to know the position. It may
* evolve to have several of the methods of the FileChannel class and plays
* a similar role.
*
* @author Steve Ratcliffe
*/
public interface ImgChannel extends ByteChannel {
/**
* Get the file position. Note that this is a logical position relative
* to the beginning of the file (the file within the .img file, not the
* beginning of the .img file itself).
*
* @return The offset in bytes from the beginning of the file.
*/
public long position();
/**
* Set the position within the file.
*
* @param pos The position to set.
*/
public void position(long pos);
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/fs/DirectoryEntry.java 0000644 0000764 0000764 00000002751 11226342005 023272 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 02-Dec-2006
*/
package uk.me.parabola.imgfmt.fs;
/**
* Interface used for directory entries used to represent files.
* A directory entry has the file name, its extension (its a 8+3 filename)
* and the size of the file.
*
* @author Steve Ratcliffe
*/
public interface DirectoryEntry {
public static final int ENTRY_SIZE = 512;
public static final int SLOTS_PER_ENTRY = 240;
/**
* Get the file name.
* @return The file name.
*/
public String getName();
/**
* Get the file extension.
* @return The file extension.
*/
public String getExt();
/**
* Get the full name. That is name + extension.
*
* @return The full name as NAME.EXT
*/
public String getFullName();
/**
* Get the file size.
* @return The size of the file in bytes.
*/
public int getSize();
/**
* If this is a special 'hidden' file. True for the all-spaces 'file'.
*
* @return True if this is not a regular file.
*/
public boolean isSpecial();
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/Utils.java 0000644 0000764 0000764 00000025265 12371067413 021012 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 03-Dec-2006
*/
package uk.me.parabola.imgfmt;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Calendar;
import java.util.Date;
import java.util.zip.GZIPInputStream;
import uk.me.parabola.imgfmt.app.Coord;
/**
* Some miscellaneous functions that are used within the .img code.
*
* @author Steve Ratcliffe
*/
public class Utils {
/**
* Routine to convert a string to bytes and pad with a character up
* to a given length.
* Only to be used for strings that are expressible in latin1.
*
* @param s The original string.
* @param len The length to pad to.
* @param pad The byte used to pad.
* @return An array created from the string.
*/
public static byte[] toBytes(String s, int len, byte pad) {
if (s == null)
throw new IllegalArgumentException("null string provided");
byte[] out = new byte[len];
for (int i = 0; i < len; i++) {
if (i > s.length()) {
out[i] = pad;
} else {
out[i] = (byte) s.charAt(i);
}
}
return out;
}
public static byte[] toBytes(String s) {
return toBytes(s, s.length(), (byte) 0);
}
/**
* Convert from bytes to a string. Only to be used when the character set
* is ascii or latin1.
*
* @param buf A byte buffer to get the bytes from. Should be ascii or latin1.
* @param off The offset into buf.
* @param len The length to get.
* @return A string.
*/
public static String bytesToString(ByteBuffer buf, int off, int len) {
if (buf == null)
throw new IllegalArgumentException("null byte buffer provided");
byte[] bbuf = new byte[len];
buf.position(off);
buf.get(bbuf);
char[] cbuf = new char[len];
for (int i = 0; i < bbuf.length; i++) {
cbuf[i] = (char) bbuf[i];
}
return new String(cbuf);
}
/**
* Set the creation date. Note that the year is encoded specially.
*
* @param buf The buffer to write into. It must have been properly positioned
* beforehand.
* @param date The date to set.
*/
public static void setCreationTime(ByteBuffer buf, Date date) {
Calendar cal = Calendar.getInstance();
if (date != null)
cal.setTime(date);
fillBufFromTime(buf, cal);
}
/**
* A map unit is an integer value that is 1/(2^24) degrees of latitude or
* longitude.
*
* @param l The lat or long as decimal degrees.
* @return An integer value in map units.
*/
public static int toMapUnit(double l) {
double DELTA = 360.0D / (1 << 24) / 2; //Correct rounding
if (l > 0)
return (int) ((l + DELTA) * (1 << 24)/360);
else
return (int) ((l - DELTA) * (1 << 24)/360);
}
/**
* Convert a date into the in-file representation of a date.
*
* @param date The date.
* @return A byte stream in .img format.
*/
public static byte[] makeCreationTime(Date date) {
Calendar cal = Calendar.getInstance();
if (date != null)
cal.setTime(date);
byte[] ret = new byte[7];
ByteBuffer buf = ByteBuffer.wrap(ret);
buf.order(ByteOrder.LITTLE_ENDIAN);
fillBufFromTime(buf, cal);
return ret;
}
private static void fillBufFromTime(ByteBuffer buf, Calendar cal) {
buf.putChar((char) cal.get(Calendar.YEAR));
buf.put((byte) (cal.get(Calendar.MONTH)+1));
buf.put((byte) cal.get(Calendar.DAY_OF_MONTH));
buf.put((byte) cal.get(Calendar.HOUR_OF_DAY));
buf.put((byte) cal.get(Calendar.MINUTE));
buf.put((byte) cal.get(Calendar.SECOND));
}
/**
* Make a date from the garmin representation.
* @param date The bytes representing the date.
* @return A java date.
*/
public static Date makeCreationTime(byte[] date) {
Calendar cal = Calendar.getInstance();
int y = ((date[1] & 0xff) << 8) + (date[0] & 0xff);
cal.set(y, date[2]-1, date[3], date[4], date[5], date[6]);
return cal.getTime();
}
/**
* Convert an angle in map units to degrees.
*/
public static double toDegrees(int val) {
return (double) val * (360.0 / (1 << 24));
}
/**
* Convert an angle in map units to radians.
*/
public static double toRadians(int mapunits) {
return toDegrees(mapunits) * (Math.PI / 180);
}
public static void closeFile(Closeable f) {
if (f != null) {
try {
f.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* Open a file and apply filters necessary for reading it such as
* decompression.
*
* @param name The file to open.
* @return A stream that will read the file, positioned at the beginning.
* @throws FileNotFoundException If the file cannot be opened for any reason.
*/
public static InputStream openFile(String name) throws FileNotFoundException {
InputStream is = new FileInputStream(name);
if (name.endsWith(".gz")) {
try {
is = new GZIPInputStream(is);
} catch (IOException e) {
throw new FileNotFoundException( "Could not read as compressed file");
}
}
return is;
}
public static String joinPath(String dir, String basename, String ext) {
return joinPath(dir, basename + "." + ext);
}
public static String joinPath(String dir, String basename) {
File file = new File(dir, basename);
return file.getAbsolutePath();
}
/**
* Rounds an integer up to the nearest multiple of {@code 2^shift}.
* Works with both positive and negative integers.
* @param val the integer to round up.
* @param shift the power of two to round up to.
* @return the rounded integer.
*/
public static int roundUp(int val, int shift) {
return (val + (1 << shift) - 1) >>> shift << shift;
}
/**
* Calculates the angle between the two segments (c1,c2),(c2,c3).
* It is assumed that the segments are rhumb lines, not great circle paths.
* @param c1 first point
* @param c2 second point
* @param c3 third point
* @return angle between the two segments in degree [-180;180]
*/
public static double getAngle(Coord c1, Coord c2, Coord c3) {
double a = c2.bearingTo(c1);
double b = c2.bearingTo(c3);
double angle = b - (a - 180);
while(angle > 180)
angle -= 360;
while(angle < -180)
angle += 360;
return angle;
}
/**
* Calculates the angle between the two segments (c1,c2),(c2,c3)
* using the coords in map units.
* @param c1 first point
* @param c2 second point
* @param c3 third point
* @return angle between the two segments in degree [-180;180]
*/
public static double getDisplayedAngle(Coord c1, Coord c2, Coord c3) {
return getAngle(c1.getDisplayedCoord(), c2.getDisplayedCoord(), c3.getDisplayedCoord());
}
public final static int NOT_STRAIGHT = 0;
public final static int STRAIGHT_SPIKE = 1;
public final static int STRICTLY_STRAIGHT = 2;
/**
* Checks if the two segments (c1,c2),(c2,c3) form a straight line.
* @param c1 first point
* @param c2 second point
* @param c3 third point
* @return NOT_STRAIGHT, STRAIGHT_SPIKE or STRICTLY_STRAIGHT
*/
public static int isStraight(Coord c1, Coord c2, Coord c3) {
if (c1.equals(c3))
return STRAIGHT_SPIKE;
long area;
// calculate the area that is enclosed by the three points
// (as if a closing line is drawn from c3 back to c1)
area = ((long)c1.getLongitude() * c2.getLatitude() -
(long)c2.getLongitude() * c1.getLatitude());
area += ((long)c2.getLongitude() * c3.getLatitude() -
(long)c3.getLongitude() * c2.getLatitude());
area += ((long)c3.getLongitude() * c1.getLatitude() -
(long)c1.getLongitude() * c3.getLatitude());
if (area == 0){
// area is empty-> points lie on a straight line
int delta1 = c1.getLatitude() - c2.getLatitude();
int delta2 = c2.getLatitude() - c3.getLatitude();
if (delta1 < 0 && delta2 > 0 || delta1 > 0 && delta2 < 0)
return STRAIGHT_SPIKE;
delta1 = c1.getLongitude() - c2.getLongitude();
delta2 = c2.getLongitude() - c3.getLongitude();
if (delta1 < 0 && delta2 > 0 || delta1 > 0 && delta2 < 0)
return STRAIGHT_SPIKE;
return STRICTLY_STRAIGHT;
}
// line is not straight
return NOT_STRAIGHT;
}
/**
* Checks if the two segments (c1,c2),(c2,c3) form a straight line
* using high precision coordinates.
* @param c1 first point
* @param c2 second point
* @param c3 third point
* @return NOT_STRAIGHT, STRAIGHT_SPIKE or STRICTLY_STRAIGHT
*/
public static int isHighPrecStraight(Coord c1, Coord c2, Coord c3) {
if (c1.highPrecEquals(c3))
return STRAIGHT_SPIKE;
long area;
long c1Lat = c1.getHighPrecLat();
long c2Lat = c2.getHighPrecLat();
long c3Lat = c3.getHighPrecLat();
long c1Lon = c1.getHighPrecLon();
long c2Lon = c2.getHighPrecLon();
long c3Lon = c3.getHighPrecLon();
// calculate the area that is enclosed by the three points
// (as if a closing line is drawn from c3 back to c1)
area = c1Lon * c2Lat - c2Lon * c1Lat;
area += c2Lon * c3Lat - c3Lon * c2Lat;
area += c3Lon * c1Lat - c1Lon * c3Lat;
if (area == 0){
// area is empty-> points lie on a straight line
long delta1 = c1Lat - c2Lat;
long delta2 = c2Lat - c3Lat;
if (delta1 < 0 && delta2 > 0 || delta1 > 0 && delta2 < 0)
return STRAIGHT_SPIKE;
delta1 = c1Lon - c2Lon;
delta2 = c2Lon - c3Lon;
if (delta1 < 0 && delta2 > 0 || delta1 > 0 && delta2 < 0)
return STRAIGHT_SPIKE;
return STRICTLY_STRAIGHT;
}
// line is not straight
return NOT_STRAIGHT;
}
/**
* approximate atan2, much faster than Math.atan2()
* Based on a 50-year old arctan approximation due to Hastings
*/
private final static double PI_BY_2 = Math.PI / 2;
// |error| < 0.005
public static double atan2_approximation( double y, double x )
{
if ( x == 0.0f )
{
if ( y > 0.0f ) return PI_BY_2 ;
if ( y == 0.0f ) return 0.0f;
return -PI_BY_2 ;
}
double atan;
double z = y/x;
if ( Math.abs( z ) < 1.0f )
{
atan = z/(1.0f + 0.28f*z*z);
if ( x < 0.0f )
{
if ( y < 0.0f ) return atan - Math.PI;
return atan + Math.PI;
}
}
else
{
atan = PI_BY_2 - z/(z*z + 0.28f);
if ( y < 0.0f ) return atan - Math.PI;
}
return atan;
}
/**
* calculate a long value for the latitude and longitude of a coord
* in high precision.
* @param co
* @return a long that can be used as a key in HashMaps
*/
public static long coord2Long(Coord co){
int lat30 = co.getHighPrecLat();
int lon30 = co.getHighPrecLon();
return (long)(lat30 & 0xffffffffL) << 32 | (lon30 & 0xffffffffL);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/MapFailedException.java 0000644 0000764 0000764 00000005316 12333157050 023401 0 ustar steve steve /*
* Copyright (C) 2010.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt;
import uk.me.parabola.log.Logger;
/**
* Used for cases where the current map has failed to compile, but the error
* is expected to be specific to the map (eg it is too big etc). When this
* error is thrown it may be possible for other maps on the command line to
* succeed.
*
* If the error is such that processing further maps is not likely to be
* successful then use {@link ExitException} instead.
*
* @author Steve Ratcliffe
*/
public class MapFailedException extends RuntimeException {
private static final Logger log = Logger.getLogger(MapFailedException.class);
/**
* Constructs a new runtime exception with the specified detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
*
* @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public MapFailedException(String message) {
super(message);
log(message);
}
/**
* Constructs a new runtime exception with the specified detail message and
* cause. Note that the detail message associated with
* cause is not automatically incorporated in
* this runtime exception's detail message.
*
* @param message the detail message (which is saved for later retrieval
* by the {@link #getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public MapFailedException(String message, Throwable cause) {
super(message, cause);
log(message);
}
private static void log(String message){
String thrownBy = "";
try{
StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
int callerPosInStack = 3;
String[] caller = stackTraceElements[callerPosInStack].getClassName().split("\\.");
thrownBy = "(thrown in " + caller[caller.length-1]+ "." +stackTraceElements[callerPosInStack].getMethodName() + "()) ";
} catch(Exception e){
log.info(e);
}
log.error(thrownBy + message);
}
} mkgmap-r3660/src/uk/me/parabola/imgfmt/FormatException.java 0000644 0000764 0000764 00000003015 11503736442 023007 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 18-Dec-2006
*/
package uk.me.parabola.imgfmt;
/**
* Thrown for any kind of malformed input to the mapping program.
*
* @author Steve Ratcliffe
*/
public class FormatException extends RuntimeException {
/**
* Constructs a new exception with the specified detail message and
* cause.
Note that the detail message associated with
* cause is not automatically incorporated in
* this exception's detail message.
*
* @param message the detail message (which is saved for later retrieval
* by the {@link #getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public FormatException(String message, Throwable cause) {
super(message, cause);
}
public FormatException(String message) {
super(message);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mdxfmt/ 0000755 0000764 0000764 00000000000 12651103763 020334 5 ustar steve steve mkgmap-r3660/src/uk/me/parabola/imgfmt/mdxfmt/MdxFileReader.java 0000644 0000764 0000764 00000003001 11532723256 023646 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.mdxfmt;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.BufferedImgFileReader;
import uk.me.parabola.imgfmt.app.ImgFileReader;
import uk.me.parabola.imgfmt.fs.ImgChannel;
/**
* For reading the MDX file.
*
* @author Steve Ratcliffe
*/
public class MdxFileReader {
private final ImgFileReader reader;
private int numberOfMaps;
private final List maps = new ArrayList();
public MdxFileReader(ImgChannel chan) {
this.reader = new BufferedImgFileReader(chan);
readHeader();
readMaps();
}
private void readMaps() {
for (int i = 0; i < numberOfMaps; i++) {
MapInfo info = new MapInfo();
info.setHexMapname(reader.getInt());
info.setProductId(reader.getChar());
info.setFamilyId(reader.getChar());
info.setMapname(reader.getInt());
maps.add(info);
}
}
private void readHeader() {
reader.getInt();
reader.getChar();
reader.getInt();
numberOfMaps = reader.getInt();
}
public List getMaps() {
return maps;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mdxfmt/MapInfo.java 0000644 0000764 0000764 00000003303 11532723256 022531 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.mdxfmt;
import java.nio.ByteBuffer;
/**
* Represents an individual file in the MDX file.
*
* I don't really understand the difference between what I call hex mapname
* and mapname. We shall always make them equal.
*
* There is no good reason to call it 'hexMapname' its just a name that stuck
* I still don't know what the difference is. We always make them the same
* but they can differ.
*/
public class MapInfo {
private int hexMapname;
private int mapname;
private char familyId;
private char productId;
private String filename;
void write(ByteBuffer os) {
os.putInt(hexMapname);
os.putChar(productId);
os.putChar(familyId);
os.putInt(mapname);
}
public int getHexMapname() {
return hexMapname;
}
public void setHexMapname(int hexMapname) {
this.hexMapname = hexMapname;
}
public void setMapname(int mapname) {
this.mapname = mapname;
}
public void setFamilyId(char familyId) {
this.familyId = familyId;
}
public void setProductId(char productId) {
this.productId = productId;
}
public int getMapname() {
return mapname;
}
public String getFilename() {
return filename;
}
public void setFilename(String filename) {
this.filename = filename;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mdxfmt/MdxFile.java 0000644 0000764 0000764 00000007335 11532723256 022541 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.mdxfmt;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.nio.channels.WritableByteChannel;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* The MDX index file. Used with the global index. This is located
* at the family level in the windows registry and can perhaps index
* across different products (and maybe families), although such a thing
* hasn't been seen.
*
* @author Steve Ratcliffe
*/
public class MdxFile {
private final char familyId;
private final char productId;
private final List maps = new ArrayList();
/**
* Create with default family and product ids.
* @param familyId The default family id that will be used if no other one
* is supplied.
* @param productId The default product id for the maps indexed by this
* file.
*/
public MdxFile(int familyId, int productId) {
this.familyId = (char) familyId;
this.productId = (char) productId;
}
/**
* Add a map with the default family and product id's and with equal
* name and hex name.
* @param name The map name (from the filename of the map) as an integer.
* @param hexname The map id that is inside the TRE header
* @param filename The file name of the map being added. Mainly for diagnostics,
* it is not needed for the file.
*/
public void addMap(int name, int hexname, String filename) {
MapInfo info = new MapInfo();
info.setHexMapname(hexname);
info.setMapname(name);
info.setFamilyId(familyId);
info.setProductId(productId);
info.setFilename(filename);
maps.add(info);
}
/**
* Write the file out to the given filename.
*/
public void write(String filename) throws IOException {
FileOutputStream stream = new FileOutputStream(filename);
FileChannel chan = stream.getChannel();
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.order(ByteOrder.LITTLE_ENDIAN);
try {
writeHeader(chan, buf);
writeBody(chan, buf);
} finally {
chan.close();
}
}
private void writeHeader(WritableByteChannel chan, ByteBuffer buf) throws IOException {
try {
buf.put("Midx".getBytes("ascii"));
} catch (UnsupportedEncodingException e) {
throw new IOException("Could not write header");
}
buf.putChar((char) 100);
buf.putInt(12);
buf.putInt(maps.size());
buf.flip();
chan.write(buf);
}
private void writeBody(WritableByteChannel chan, ByteBuffer buf) throws IOException {
// Sort the maps by the hex number.
Collections.sort(maps, new Comparator() {
public int compare(MapInfo o1, MapInfo o2) {
if (o1.getHexMapname() == o2.getHexMapname())
return 0;
else if (o1.getHexMapname() < o2.getHexMapname())
return -1;
else
return 1;
}
});
for (MapInfo info : maps) {
// Although its not necessarily wrong for them to be zero, it probably
// sign that something is wrong.
if (info.getHexMapname() == 0 || info.getMapname() == 0)
System.err.println("Invalid mapname for " + info.getFilename() + ", perhaps it is not a .img file");
buf.compact();
info.write(buf);
buf.flip();
chan.write(buf);
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/ 0000755 0000764 0000764 00000000000 12651103763 017653 5 ustar steve steve mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/ImgFS.java 0000644 0000764 0000764 00000024641 11763457463 021506 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 26-Nov-2006
*/
package uk.me.parabola.imgfmt.sys;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.channels.FileChannel;
import java.util.List;
import uk.me.parabola.imgfmt.FileExistsException;
import uk.me.parabola.imgfmt.FileNotWritableException;
import uk.me.parabola.imgfmt.FileSystemParam;
import uk.me.parabola.imgfmt.fs.DirectoryEntry;
import uk.me.parabola.imgfmt.fs.FileSystem;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.log.Logger;
/**
* The img file is really a filesystem containing several files.
* It is made up of a header, a directory area and a data area which
* occur in the filesystem in that order.
*
* @author steve
*/
public class ImgFS implements FileSystem {
private static final Logger log = Logger.getLogger(ImgFS.class);
// The directory is just like any other file, but with a name of 8+3 spaces
static final String DIRECTORY_FILE_NAME = " . ";
// This is the read or write channel to the real file system.
private final FileChannel file;
private boolean readOnly = true;
// The header contains general information.
private ImgHeader header;
// There is only one directory that holds all filename and block allocation
// information.
private Directory directory;
// The filesystem is responsible for allocating blocks
private BlockManager fileBlockManager;
// The header entries are written in 512 blocks, regardless of the block size of the file itself.
private static final long ENTRY_BLOCK_SIZE = 512L;
private BlockManager headerBlockManager;
private byte xorByte; // if non-zero, all bytes are XORed with this
/**
* Private constructor, use the static {@link #createFs} and {@link #openFs}
* routines to make a filesystem.
*
* @param chan The open file.
*/
private ImgFS(FileChannel chan) {
file = chan;
}
/**
* Create an IMG file from its external filesystem name and optionally some
* parameters.
*
* @param filename The name of the file to be created.
* @param params File system parameters. Can not be null.
* @throws FileNotWritableException If the file can not be written to.
*/
public static FileSystem createFs(String filename, FileSystemParam params) throws FileNotWritableException {
params.setFilename(filename);
try {
RandomAccessFile rafile = new RandomAccessFile(filename, "rw");
return createFs(rafile.getChannel(), params);
} catch (FileNotFoundException e) {
throw new FileNotWritableException("Could not create file: " + params.getFilename(), e);
}
}
private static FileSystem createFs(FileChannel chan, FileSystemParam params)
throws FileNotWritableException
{
assert params != null;
// Truncate the file, because extra bytes beyond the end make for a
// map that doesn't work on the GPS (although its likely to work in
// other software viewers).
try {
chan.truncate(0);
} catch (IOException e) {
throw new FileNotWritableException("Failed to truncate file", e);
}
ImgFS fs = new ImgFS(chan);
fs.createInitFS(chan, params);
return fs;
}
/**
* Open an existing IMG file system.
* @param name The file name to open.
* @return A File system that can be used lookup the internal files.
* @throws FileNotFoundException When the file doesn't exist or can't be
* read.
*/
public static FileSystem openFs(String name) throws FileNotFoundException {
RandomAccessFile rafile = new RandomAccessFile(name, "r");
return openFs(name, rafile.getChannel());
}
private static FileSystem openFs(String name, FileChannel chan) throws FileNotFoundException {
ImgFS fs = new ImgFS(chan);
try {
fs.readInitFS(chan);
} catch (IOException e) {
throw new FileNotFoundException(name + ": " + e.getMessage());
}
return fs;
}
/**
* Create a new file, it must not already exist.
*
* @param name The file name.
* @return A directory entry for the new file.
*/
public ImgChannel create(String name) throws FileExistsException {
Dirent dir = directory.create(name, fileBlockManager);
return new FileNode(file, dir, "w");
}
/**
* Open a file. The returned file object can be used to read and write the
* underlying file.
*
* @param name The file name to open.
* @param mode Either "r" for read access, "w" for write access or "rw"
* for both read and write.
* @return A file descriptor.
* @throws FileNotFoundException When the file does not exist.
*/
public ImgChannel open(String name, String mode) throws FileNotFoundException {
if (name == null || mode == null)
throw new IllegalArgumentException("null argument");
if (mode.indexOf('r') >= 0) {
Dirent ent = internalLookup(name);
FileNode fn = new FileNode(file, ent, "r");
if(xorByte != 0)
fn.setXorByte(xorByte);
return fn;
} else if (mode.indexOf('w') >= 0) {
Dirent ent;
try {
ent = internalLookup(name);
} catch (FileNotFoundException e) {
try {
ent = directory.create(name, fileBlockManager);
} catch (FileExistsException e1) {
// This shouldn't happen as we have just checked.
throw new FileNotFoundException("Attempt to duplicate a file name");
}
}
return new FileNode(file, ent, "w");
} else {
throw new IllegalArgumentException("Invalid mode given");
}
}
/**
* Lookup the file and return a directory entry for it.
*
* @param name The filename to look up.
* @return A directory entry.
* @throws FileNotFoundException If an error occurs looking for the file,
* including it not existing.
*/
public DirectoryEntry lookup(String name) throws FileNotFoundException {
return internalLookup(name);
}
/**
* List all the files in the directory.
*
* @return A List of directory entries.
*/
public List list() {
return directory.getEntries();
}
public FileSystemParam fsparam() {
return header.getParams();
}
public void fsparam(FileSystemParam param) {
int reserved = param.getReservedDirectoryBlocks() + 2;
fileBlockManager.setCurrentBlock(reserved);
headerBlockManager.setMaxBlock(reserved);
}
/**
* Sync with the underlying file. All unwritten data is written out to
* the underlying file.
*
* @throws IOException If an error occurs during the write.
*/
public void sync() throws IOException {
if (readOnly)
return;
header.setNumBlocks(fileBlockManager.getMaxBlockAllocated());
header.sync();
directory.sync();
}
/**
* Close the filesystem. Any saved data is flushed out. It is better
* to explicitly sync the data out first, to be sure that it has worked.
*/
public void close() {
try {
sync();
} catch (IOException e) {
log.debug("could not sync filesystem");
} finally {
try {
file.close();
} catch (IOException e) {
log.warn("Could not close file");
}
}
}
/**
* Set up and ImgFS that has just been created.
*
* @param chan The real underlying file to write to.
* @param params The file system parameters.
* @throws FileNotWritableException If the file cannot be written for any
* reason.
*/
private void createInitFS(FileChannel chan, FileSystemParam params) throws FileNotWritableException {
readOnly = false;
// The block manager allocates blocks for files.
headerBlockManager = new BlockManager(params.getBlockSize(), 0);
headerBlockManager.setMaxBlock(params.getReservedDirectoryBlocks());
// This bit is tricky. We want to use a regular ImgChannel to write
// to the header and directory, but to create one normally would involve
// it already existing, so it is created by hand.
try {
directory = new Directory(headerBlockManager, params.getDirectoryStartEntry());
Dirent ent = directory.create(DIRECTORY_FILE_NAME, headerBlockManager);
ent.setSpecial(true);
ent.setInitialized(true);
FileNode f = new FileNode(chan, ent, "w");
directory.setFile(f);
header = new ImgHeader(f);
header.createHeader(params);
} catch (FileExistsException e) {
throw new FileNotWritableException("Could not create img file directory", e);
}
fileBlockManager = new BlockManager(params.getBlockSize(), params.getReservedDirectoryBlocks());
assert header != null;
}
/**
* Initialise a filesystem that is going to be read from. We need to read
* in the header including directory.
*
* @param chan The file channel to read from.
* @throws IOException If the file cannot be read.
*/
private void readInitFS(FileChannel chan) throws IOException {
ByteBuffer headerBuf = ByteBuffer.allocate(512);
headerBuf.order(ByteOrder.LITTLE_ENDIAN);
chan.read(headerBuf);
xorByte = headerBuf.get(0);
if(xorByte != 0) {
byte[] headerBytes = headerBuf.array();
for(int i = 0; i < headerBytes.length; ++i)
headerBytes[i] ^= xorByte;
}
if (headerBuf.position() < 512)
throw new IOException("File too short or corrupted");
header = new ImgHeader(null);
header.setHeader(headerBuf);
FileSystemParam params = header.getParams();
BlockManager headerBlockManager = new BlockManager(params.getBlockSize(), 0);
headerBlockManager.setMaxBlock(params.getReservedDirectoryBlocks());
directory = new Directory(headerBlockManager, params.getDirectoryStartEntry());
directory.setStartPos(params.getDirectoryStartEntry() * ENTRY_BLOCK_SIZE);
Dirent ent = directory.create(DIRECTORY_FILE_NAME, headerBlockManager);
FileNode f = new FileNode(chan, ent, "r");
header.setFile(f);
directory.setFile(f);
directory.readInit(xorByte);
}
/**
* Lookup the file and return a directory entry for it.
*
* @param name The filename to look up.
* @return A directory entry.
* @throws FileNotFoundException If an error occurs reading the directory.
*/
private Dirent internalLookup(String name) throws FileNotFoundException {
if (name == null)
throw new IllegalArgumentException("null name argument");
Dirent ent = (Dirent) directory.lookup(name);
if (ent == null)
throw new FileNotFoundException(name + " not found");
return ent;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/FileNode.java 0000644 0000764 0000764 00000021566 11256647151 022221 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 03-Dec-2006
*/
package uk.me.parabola.imgfmt.sys;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousCloseException;
import java.nio.channels.ClosedByInterruptException;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.FileChannel;
import java.nio.channels.NonReadableChannelException;
import java.nio.channels.NonWritableChannelException;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.log.Logger;
/**
* The internal representation of a file in the file system. In use it
* should only be referred to by the {@link ImgChannel} interface.
*
* @author Steve Ratcliffe
*/
public class FileNode implements ImgChannel {
private static final Logger log = Logger.getLogger(FileNode.class);
private boolean open;
private boolean writeable;
private boolean readable;
private final FileChannel file;
private final BlockManager blockManager;
private final Dirent dirent;
// The position in this file
private long position;
private byte xorByte;
/**
* Creates a new file in the file system. You can treat this just like
* a regular file and write or read from it.
* Operations to two different files may not be interleaved although
* it may be possible to implement this.
*
* @param file The handle to the underlying file.
* @param dir The directory entry associated with this file.
* @param mode The mode "rw" for read and write etc.
*/
public FileNode(FileChannel file, Dirent dir, String mode)
{
this.file = file;
this.dirent = dir;
if (mode.indexOf('r') >= 0)
readable = true;
if (mode.indexOf('w') >= 0)
writeable = true;
if (!(readable || writeable))
throw new IllegalArgumentException("File must be readable or writeable");
blockManager = dir.getBlockManager();
if (blockManager == null)
throw new IllegalArgumentException("no file system supplied");
open = true;
}
/**
* Closes this channel.
*
* After a channel is closed, any further attempt to invoke I/O
* operations upon it will cause a {@link ClosedChannelException} to be
* thrown.
*
* If this channel is already closed then invoking this method has no
* effect.
*
* This method may be invoked at any time. If some other thread has
* already invoked it, however, then another invocation will block until
* the first invocation is complete, after which it will return without
* effect.
*
* @throws IOException If an I/O error occurs
*/
public void close() throws IOException {
if (!open)
return;
sync();
open = false;
readable = false;
writeable = false;
}
/**
* Tells whether or not this channel is open.
*
* @return true if, and only if, this channel is open
*/
public boolean isOpen() {
return open;
}
/**
* Reads a sequence of bytes from this channel into the given buffer.
*
* @param dst The buffer into which bytes are to be transferred
*
* @return The number of bytes read, possibly zero, or -1 if the
* channel has reached end-of-stream
*
* @throws NonReadableChannelException If this channel was not opened for reading
* @throws ClosedChannelException If this channel is closed
* @throws AsynchronousCloseException If another thread closes this channel
* while the read operation is in progress
* @throws ClosedByInterruptException If another thread interrupts the
* current thread while the read operation is in progress, thereby closing
* the channel and setting the current thread's interrupt status
* @throws IOException If some other I/O error occurs
*/
public int read(ByteBuffer dst) throws IOException {
if (!open)
throw new ClosedChannelException();
if (!readable)
throw new NonReadableChannelException();
int blockSize = blockManager.getBlockSize();
long size = dst.remaining();
long fileSize = dirent.getSize();
if (position >= fileSize)
return -1;
size = Math.min(size, fileSize - position);
int totalRead = 0;
while (size > 0) {
// Tet the logical block number, as we see it in our file.
int lblock = (int) (position / blockSize);
// Get the physical block number, the actual block number in
// the underlying file.
int pblock = dirent.getPhysicalBlock(lblock);
if (pblock == 0xffff) {
// We are at the end of the file.
log.debug("at eof");
break;
}
// Position the underlying file
int off = (int) (position - lblock*blockSize);
file.position((long) pblock * blockSize + off);
int n = (int) size;
if (n > blockSize)
n = blockSize;
if (off != 0)
n = Math.min(n, blockSize - off);
dst.limit(dst.position() + n);
int pos = dst.position();
int nr = file.read(dst);
if (nr == -1)
return -1;
if (nr == 0)
throw new IOException("Read nothing");
if(xorByte != 0) {
byte[] bufBytes = dst.array();
for(int i = pos + n - 1; i >= pos; --i)
bufBytes[i] ^= xorByte;
}
// Update the file positions
size -= nr;
position += nr;
totalRead += nr;
}
log.debug("read ret", totalRead);
return totalRead;
}
/**
* Writes a sequence of bytes to this channel from the given buffer.
*
* An attempt is made to write up to r bytes to the channel,
* where r is the number of bytes remaining in the buffer, that is,
* dst.remaining(), at the moment this method is invoked.
*
The logical block has to be converted to a physical block in the
* underlying file.
*
* @param src The buffer from which bytes are to be retrieved
* @return The number of bytes written, possibly zero
* @throws NonWritableChannelException
* If this channel was not opened for writing
* @throws ClosedChannelException
* If this channel is closed
* @throws IOException If some other I/O error occurs
*/
public int write(ByteBuffer src) throws IOException {
if (!open)
throw new ClosedChannelException();
int blockSize = blockManager.getBlockSize();
// Get the size of this write
int size = src.remaining();
// Loop over each block, this is to support the case (which we may
// not implement) of non-contiguous blocks.
int totalWritten = 0;
while (size > 0) {
// Get the logical block, ie the block as we see it in our file.
int lblock = (int) (position/blockSize);
// First need to allocate enough blocks for this write. First check
// if the block exists already
int pblock = dirent.getPhysicalBlock(lblock);
log.debug("lblock / pblock", lblock, '/', pblock);
if (pblock == 0xffff) {
log.debug("allocating new block");
pblock = blockManager.allocate();
dirent.addBlock(pblock);
}
// Position the underlying file, so that it is in the correct place.
int off = (int) (position - lblock*blockSize);
file.position((long) pblock * blockSize + off);
int n = size;
if (n > blockSize)
n = blockSize;
if (off != 0)
n = Math.min(n, blockSize - off);
src.limit(src.position() + n);
// Write to the underlying file.
int nw = file.write(src);
if (nw == 0)
throw new IOException("Wrote nothing");
// Update the file positions
size -= nw;
position += nw;
totalWritten += nw;
// Update file size.
if (position > dirent.getSize())
dirent.setSize((int) position);
}
return totalWritten;
}
public long position() {
return position;
}
public void position(long pos) {
int blockSize = blockManager.getBlockSize();
while (pos > position) {
long lblock = position / blockSize;
int pblock = dirent.getPhysicalBlock((int) lblock);
if (pblock == 0xffff) {
if (writeable) {
log.debug("setting position allocating new block", lblock);
pblock = blockManager.allocate();
dirent.addBlock(pblock);
}
}
position = (lblock+1) * blockSize;
}
this.position = pos;
}
/**
* Write out any unsaved data to disk.
*
* @throws IOException If there is an error writing to disk.
*/
private void sync() throws IOException {
if (!writeable)
return;
// Ensure that a complete block is written out.
int bs = blockManager.getBlockSize();
long rem = bs - (file.position() % bs);
ByteBuffer buf = ByteBuffer.allocate(blockManager.getBlockSize());
// Complete any partial block.
for (int i = 0; i < rem; i++)
buf.put((byte) 0);
buf.flip();
file.write(buf);
}
public void setXorByte(byte xorByte) {
this.xorByte = xorByte;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/BlockManager.java 0000644 0000764 0000764 00000004475 11562201364 023051 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 25-Oct-2007
*/
package uk.me.parabola.imgfmt.sys;
import uk.me.parabola.imgfmt.MapFailedException;
import uk.me.parabola.log.Logger;
/**
* This is used to allocate blocks for files in the filesystem/archive.
*
* @author Steve Ratcliffe
*/
class BlockManager {
private static final Logger log = Logger.getLogger(BlockManager.class);
private final int blockSize;
private int currentBlock;
private int maxBlock = 0xfffe;
private int maxBlockAllocated;
private final int initialBlock;
BlockManager(int blockSize, int initialBlock) {
this.blockSize = blockSize;
this.currentBlock = initialBlock;
this.initialBlock = initialBlock;
this.maxBlockAllocated = initialBlock;
}
/**
* Well the algorithm is pretty simple - you just get the next unused block
* number.
*
* @return A block number that is free to be used.
*/
public int allocate() {
int n = currentBlock++;
if (maxBlock > 0 && n > maxBlock) {
log.error("overflowed directory with max block " + maxBlock + ", current=" + n);
// This problem is fixable so give some useful advice on what
// to do about it
String message = String.format("Too many blocks." +
" Use a larger block size with an option such as" +
" --block-size=%d or --block-size=%d",
blockSize * 2, blockSize * 4);
throw new MapFailedException(message);
}
maxBlockAllocated++;
return n;
}
public int getBlockSize() {
return blockSize;
}
public int getMaxBlock() {
return maxBlock;
}
public void setMaxBlock(int maxBlock) {
this.maxBlock = maxBlock;
}
public void setCurrentBlock(int n) {
if (maxBlockAllocated != initialBlock)
throw new IllegalStateException("Blocks already allocated");
currentBlock = n;
maxBlockAllocated = n;
}
public int getMaxBlockAllocated() {
return maxBlockAllocated;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/Dirent.java 0000644 0000764 0000764 00000015430 11503736442 021747 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 30-Nov-2006
*/
package uk.me.parabola.imgfmt.sys;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.fs.DirectoryEntry;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.log.Logger;
/**
* An entry within a directory. This holds its name and a list
* of blocks that go to make up this file.
*
* A directory entry may take more than block in the file system.
*
*
All documentation seems to point to the block numbers having to be
* contiguous, but seems strange so I shall experiment.
*
*
Entries are in blocks of 512 bytes, regardless of the block size.
*
* @author Steve Ratcliffe
*/
class Dirent implements DirectoryEntry {
protected static final Logger log = Logger.getLogger(Dirent.class);
// Constants.
static final int MAX_FILE_LEN = 8;
static final int MAX_EXT_LEN = 3;
// Offsets
static final int OFF_FILE_USED = 0x00;
static final int OFF_NAME = 0x01;
static final int OFF_EXT = 0x09;
static final int OFF_FLAG = 0x10;
static final int OFF_FILE_PART = 0x11;
private static final int OFF_SIZE = 0x0c;
// File names are a base+extension
private String name;
private String ext;
// The file size.
private int size;
private final BlockManager blockManager;
// The block table holds all the blocks that belong to this file. The
// documentation suggests that block numbers are always contiguous.
private final BlockTable blockTable;
private boolean special;
private static final int OFF_USED_FLAG = 0;
private boolean initialized;
Dirent(String name, BlockManager blockManager) {
this.blockManager = blockManager;
int dot = name.lastIndexOf('.');
if (dot >= 0) {
setName(name.substring(0, dot));
setExt(name.substring(dot+1));
} else
throw new IllegalArgumentException("Filename did not have dot");
blockTable = new BlockTable();
}
/**
* Write this entry out to disk. Note that these are 512 bytes, regardless
* of the block size.
*
* @param file The file to write to.
* @throws IOException If writing fails for any reason.
*/
void sync(ImgChannel file) throws IOException {
int ntables = blockTable.getNBlockTables();
ByteBuffer buf = ByteBuffer.allocate(ENTRY_SIZE * ntables);
buf.order(ByteOrder.LITTLE_ENDIAN);
for (int part = 0; part < ntables; part++) {
log.debug("position at part", part, "is", buf.position());
buf.put((byte) 1);
buf.put(Utils.toBytes(name, MAX_FILE_LEN, (byte) ' '));
buf.put(Utils.toBytes(ext, MAX_EXT_LEN, (byte) ' '));
// Size is only present in the first part
if (part == 0) {
log.debug("dirent", name, '.', ext, "size is going to", size);
buf.putInt(size);
} else {
buf.putInt(0);
}
buf.put((byte) (special? 0x3: 0));
buf.putChar((char) part);
// Write out the allocation of blocks for this entry.
buf.position(ENTRY_SIZE * part + 0x20);
blockTable.writeTable(buf, part);
}
buf.flip();
file.write(buf);
}
/**
* Get the file name.
*
* @return The file name.
*/
public String getName() {
return name;
}
/**
* Get the file extension.
*
* @return The file extension.
*/
public String getExt() {
return ext;
}
/**
* The full name is of the form 8+3 with a dot in between the name and
* extension. The full name is used as the index in the directory.
*
* @return The full name.
*/
public String getFullName() {
return name + '.' + ext;
}
/**
* Read in the block numbers from the given buffer. If this is the first
* directory block for this file, then the size is set too.
*
* @param buf The data as read from the file.
*/
void initBlocks(ByteBuffer buf) {
byte used = buf.get(OFF_USED_FLAG);
if (used != 1)
return;
int part = buf.get(OFF_FILE_PART) & 0xff;
if (part == 0 || (isSpecial() && part == 3))
size = buf.getInt(OFF_SIZE);
blockTable.readTable(buf);
initialized = true;
}
/**
* Get the file size.
*
* @return The size of the file in bytes.
*/
public int getSize() {
return size;
}
/**
* Set the file name. The name should be exactly eight characters long
* and it is truncated or left padded with zeros to make this true.
*
* @param name The file name.
*/
private void setName(String name) {
int len = name.length();
if (len > MAX_FILE_LEN) {
this.name = name.substring(0, 8);
} else if (len < MAX_FILE_LEN) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < MAX_FILE_LEN - len; i++) {
sb.append('0');
}
sb.append(name);
this.name = sb.toString();
} else
this.name = name;
}
/**
* Set the file extension. Can't be longer than three characters.
* @param ext The file extension.
*/
private void setExt(String ext) {
log.debug("ext len", ext.length());
if (ext.length() != MAX_EXT_LEN)
throw new IllegalArgumentException("File extension is wrong size");
this.ext = ext;
}
/**
* The number of blocks that the header covers. The header includes
* the directory for the purposes of this routine.
*
* @return The total number of header basic blocks (blocks of 512 bytes).
*/
int numberHeaderBlocks() {
return blockTable.getNBlockTables();
}
void setSize(int size) {
if (log.isDebugEnabled())
log.debug("setting size", getName(), getExt(), "to", size);
this.size = size;
}
/**
* Add a block without increasing the size of the file.
*
* @param n The block number.
*/
void addBlock(int n) {
blockTable.addBlock(n);
}
/**
* Set for the first directory entry that covers the header and directory
* itself.
*
* @param special Set to true to mark as the special first entry.
*/
public void setSpecial(boolean special) {
this.special = special;
}
public boolean isSpecial() {
return special;
}
/**
* Converts from a logical block to a physical block. If the block does
* not exist then 0xffff will be returned.
*
* @param lblock The logical block in the file.
* @return The corresponding physical block in the filesystem.
*/
public int getPhysicalBlock(int lblock) {
return blockTable.physFromLogical(lblock);
}
public BlockManager getBlockManager() {
return blockManager;
}
protected void setInitialized(boolean initialized) {
this.initialized = initialized;
}
protected boolean isInitialized() {
return initialized;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/FileImgChannel.java 0000644 0000764 0000764 00000004651 11532723256 023333 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 14, 2007
*/
package uk.me.parabola.imgfmt.sys;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import uk.me.parabola.imgfmt.ReadFailedException;
import uk.me.parabola.imgfmt.fs.ImgChannel;
/**
* This is an implementation of ImgChannel that delegates to a regular channel.
* It can therefore be used to read or write regular files on the file system.
*
* @author Steve Ratcliffe
*/
public class FileImgChannel implements ImgChannel {
private final FileChannel channel;
private long position;
public FileImgChannel(String filename, String mode) {
RandomAccessFile raf;
try {
raf = new RandomAccessFile(filename, mode);
} catch (FileNotFoundException e) {
throw new ReadFailedException("Could not open " + filename, e);
}
this.channel = raf.getChannel();
}
public FileImgChannel(FileChannel channel) {
this.channel = channel;
}
public int read(ByteBuffer dst) throws IOException {
int n = channel.read(dst);
if (n > 0)
position += n;
return n;
}
public boolean isOpen() {
return channel.isOpen();
}
public void close() throws IOException {
channel.close();
}
public int write(ByteBuffer src) throws IOException {
int n = channel.write(src);
position += n;
return n;
}
/**
* Get the file position. Note that this is a logical position relative to the
* beginning of the file (the file within the .img file, not the beginning of the
* .img file itself).
*
* @return The offset in bytes from the beginning of the file.
*/
public long position() {
return position;
}
/**
* Set the position within the file.
*
* @param pos The position to set.
*/
public void position(long pos) {
try {
channel.position(pos);
position = pos;
} catch (IOException e) {
throw new ReadFailedException("Could not seek", e);
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/package.html 0000644 0000764 0000764 00000000566 11154317465 022146 0 ustar steve steve
Filesystem implementation
This holds the filesystem implementation for the .img
format. I refer through out to a file system containing
files, rather than using the term sub-files as in John Mechalas'
document.
Another way to look at it (and probably a better one) is that it a kind
of archive format just like a .zip file.
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/BlockTable.java 0000644 0000764 0000764 00000007131 11503736442 022523 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 03-Feb-2007
*/
package uk.me.parabola.imgfmt.sys;
import uk.me.parabola.log.Logger;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Holds block numbers for a file. It is part of the directory. For a file
* that needs more than one block several directory entries exist. Each of
* these has the header with the file name etc. in it, but the first one has
* extra flags and info.
*
* What is important here is that only part of a full block is used to
* hold block numbers.
*
*
The entries are 512 bytes regardless of the block size.
*
* @author Steve Ratcliffe
*/
class BlockTable {
private static final Logger log = Logger.getLogger(BlockTable.class);
// Offset of the block table in the directory entry block.
private static final int BLOCKS_TABLE_START = 0x20;
private static final int ENTRY_SIZE = 512;
private static final int TABLE_SIZE = (ENTRY_SIZE - BLOCKS_TABLE_START)/2;
//private final int tableSize;
private int curroff;
private final List blocks;
private char[] currTable;
BlockTable() {
blocks = new ArrayList(200);
}
/**
* Write out the specified table to the given buffer.
*
* @param buf The buffer to write to.
* @param n The number of the block table to write out.
*/
public void writeTable(ByteBuffer buf, int n) {
char[] cbuf = blocks.get(n);
log.debug("block with length", cbuf.length);
for (char c : cbuf) {
buf.putChar(c);
}
}
/**
* Read a block table from the given buffer. The table is added to the
* list.
* @param buf The buffer to read from.
*/
public void readTable(ByteBuffer buf) {
buf.position(BLOCKS_TABLE_START);
buf.limit(ENTRY_SIZE);
char[] cbuf = newTable();
for (int i = 0; i < cbuf.length; i++) {
char c = buf.getChar();
cbuf[i] = c;
}
}
/**
* Add the given block number to this directory.
*
* @param n The block number to add.
*/
public void addBlock(int n) {
char[] thisTable = currTable;
if (curroff >= TABLE_SIZE || currTable == null)
thisTable = newTable();
thisTable[curroff++] = (char) n;
}
/**
* Given a logical block number, return the physical block number.
*
* @param lblock The logical block number, ie with respect to the file.
* @return The physical block number in the file system.
*/
public int physFromLogical(int lblock) {
int blockNum = lblock / TABLE_SIZE;
int offset = lblock - blockNum * TABLE_SIZE;
if (blockNum >= blocks.size())
return 0xffff;
char[] cbuf = blocks.get(blockNum);
return cbuf[offset];
}
/**
* Get the number of block tables. This is the number of blocks that
* will be used in the on disk directory structure.
*
* @return The number of blocks tables.
*/
public int getNBlockTables() {
return blocks.size();
}
/**
* Allocate a new block to hold more directory block numbers.
*
* @return Array for more numbers.
*/
private char[] newTable() {
char[] table = new char[TABLE_SIZE];
Arrays.fill(table, (char) 0xffff);
curroff = 0;
blocks.add(table);
currTable = table;
return table;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/Directory.java 0000644 0000764 0000764 00000014657 12323435234 022474 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 26-Nov-2006
*/
package uk.me.parabola.imgfmt.sys;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import uk.me.parabola.imgfmt.FileExistsException;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.fs.DirectoryEntry;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.log.Logger;
/**
* The directory. There is only one directory and it contains the
* file names and block information. On disk each entry is a
* multiple of the block size.
*
* @author Steve Ratcliffe
*/
class Directory {
private static final Logger log = Logger.getLogger(Directory.class);
//private final FileChannel file;
private ImgChannel chan;
private final BlockManager headerBlockManager;
private final int startEntry;
private long startPos;
// The list of files themselves.
private final Map entries = new LinkedHashMap();
Directory(BlockManager headerBlockManager, int startEntry) {
this.headerBlockManager = headerBlockManager;
this.startEntry = startEntry;
}
/**
* Create a new file in the directory.
*
* @param name The file name. Must be 8+3 characters.
* @param blockManager To allocate blocks for the created file entry.
* @return The new directory entity.
* @throws FileExistsException If the entry already
* exists.
*/
Dirent create(String name, BlockManager blockManager) throws FileExistsException {
// Check to see if it is already there.
if (entries.get(name) != null)
throw new FileExistsException("File " + name + " already exists");
Dirent ent;
if (name.equals(ImgFS.DIRECTORY_FILE_NAME)) {
ent = new HeaderDirent(name, blockManager);
} else {
ent = new Dirent(name, blockManager);
}
addEntry(ent);
return ent;
}
/**
* Initialise the directory for reading the file. The whole directory
* is read in.
*
* @throws IOException If it cannot be read.
*/
void readInit(byte xorByte) throws IOException {
assert chan != null;
ByteBuffer buf = ByteBuffer.allocate(512);
buf.order(ByteOrder.LITTLE_ENDIAN);
chan.position(startPos);
Dirent current = null;
while ((chan.read(buf)) > 0) {
buf.flip();
if(xorByte != 0) {
byte[] bufBytes = buf.array();
for(int i = 0; i < bufBytes.length; ++i)
bufBytes[i] ^= xorByte;
}
int used = buf.get(Dirent.OFF_FILE_USED);
if (used != 1)
continue;
String name = Utils.bytesToString(buf, Dirent.OFF_NAME, Dirent.MAX_FILE_LEN);
String ext = Utils.bytesToString(buf, Dirent.OFF_EXT, Dirent.MAX_EXT_LEN);
log.debug("readinit name", name, ext);
int flag = buf.get(Dirent.OFF_FLAG);
int part = buf.get(Dirent.OFF_FILE_PART) & 0xff;
if (flag == 3 && current == null) {
current = (Dirent) entries.get(ImgFS.DIRECTORY_FILE_NAME);
current.initBlocks(buf);
} else if (part == 0) {
current = create(name + '.' + ext, headerBlockManager);
current.initBlocks(buf);
} else {
assert current != null;
current.initBlocks(buf);
}
buf.clear();
}
}
/**
* Write out the directory to the file. The file should be correctly
* positioned by the caller.
*
* @throws IOException If there is a problem writing out any
* of the directory entries.
*/
public void sync() throws IOException {
// The first entry can't really be written until the rest of the directory is
// so we have to step through once to calculate the size and then again
// to write it out.
int headerEntries = 0;
for (DirectoryEntry dir : entries.values()) {
Dirent ent = (Dirent) dir;
log.debug("ent size", ent.getSize());
int n = ent.numberHeaderBlocks();
headerEntries += n;
}
// Save the current position
long dirPosition = chan.position();
int blockSize = headerBlockManager.getBlockSize();
// Get the number of blocks required for the directory entry representing the header.
// First calculate the number of blocks required for the directory entries.
int headerBlocks = (int) Math.ceil((startEntry + 1.0 + headerEntries) * DirectoryEntry.ENTRY_SIZE / blockSize);
int forHeader = (headerBlocks + DirectoryEntry.ENTRY_SIZE - 1)/DirectoryEntry.ENTRY_SIZE;
log.debug("header blocks needed", forHeader);
// There is nothing really wrong with larger values (perhaps, I don't
// know for sure!) but the code is written to make it 1, so make sure that it is.
assert forHeader == 1;
// Write the blocks that will will contain the header blocks.
chan.position(dirPosition + (long) forHeader * DirectoryEntry.ENTRY_SIZE);
for (DirectoryEntry dir : entries.values()) {
Dirent ent = (Dirent) dir;
if (!ent.isSpecial()) {
log.debug("wrting ", dir.getFullName(), " at ", chan.position());
log.debug("ent size", ent.getSize());
ent.sync(chan);
}
}
long end = (long) blockSize * headerBlockManager.getMaxBlock();
ByteBuffer buf = ByteBuffer.allocate((int) (end - chan.position()));
for (int i = 0; i < buf.capacity(); i++)
buf.put((byte) 0);
buf.flip();
chan.write(buf);
// Now go back and write in the directory entry for the header.
chan.position(dirPosition);
Dirent ent = (Dirent) entries.values().iterator().next();
log.debug("ent header size", ent.getSize());
ent.sync(chan);
}
/**
* Get the entries. Used for listing the directory.
*
* @return A list of the directory entries. They will be in the same
* order as in the file.
*/
public List getEntries() {
return new ArrayList(entries.values());
}
/**
* Add an entry to the directory.
*
* @param ent The entry to add.
*/
private void addEntry(DirectoryEntry ent) {
entries.put(ent.getFullName(), ent);
}
public void setFile(ImgChannel chan) {
this.chan = chan;
}
public void setStartPos(long startPos) {
this.startPos = startPos;
}
public DirectoryEntry lookup(String name) {
return entries.get(name);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/ImgHeader.java 0000644 0000764 0000764 00000030565 11771656621 022364 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 26-Nov-2006
*/
package uk.me.parabola.imgfmt.sys;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Calendar;
import java.util.Date;
import uk.me.parabola.imgfmt.FileSystemParam;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.log.Logger;
import static java.util.Arrays.asList;
/**
* The header at the very beginning of the .img filesystem. It has the
* same signature as a DOS partition table, although I don't know
* exactly how much the partition concepts are used.
*
* @author Steve Ratcliffe
*/
class ImgHeader {
private static final Logger log = Logger.getLogger(ImgHeader.class);
// Offsets into the header.
private static final int OFF_XOR = 0x0;
private static final int OFF_UPDATE_MONTH = 0xa;
private static final int OFF_UPDATE_YEAR = 0xb; // +1900 for val >= 0x63, +2000 for less
private static final int OFF_SUPP = 0xe; // Appears to be set for gmapsupp files
private static final int OFF_CHECKSUM = 0xf;
private static final int OFF_SIGNATURE = 0x10;
private static final int OFF_UNK_1 = 0x17;
// If this was a real boot sector these would be the meanings
private static final int OFF_SECTORS = 0x18;
private static final int OFF_HEADS = 0x1a;
private static final int OFF_CYLINDERS = 0x1c;
private static final int OFF_CREATION_DATE = 0x39;
// The block number where the directory starts.
private static final int OFF_DIRECTORY_START_BLOCK = 0x40;
private static final int OFF_MAP_FILE_INTENTIFIER = 0x41;
private static final int OFF_MAP_DESCRIPTION = 0x49; // 0x20 padded
private static final int OFF_HEADS2 = 0x5d;
private static final int OFF_SECTORS2 = 0x5f;
private static final int OFF_BLOCK_SIZE_EXPONENT1 = 0x61;
private static final int OFF_BLOCK_SIZE_EXPONENT2 = 0x62;
private static final int OFF_BLOCK_SIZE = 0x63;
// private static final int OFF_UKN_3 = 0x63;
private static final int OFF_MAP_NAME_CONT = 0x65;
// 'Partition table' offsets.
private static final int OFF_START_HEAD = 0x1bf;
private static final int OFF_START_SECTOR = 0x1c0;
private static final int OFF_START_CYLINDER = 0x1c1;
private static final int OFF_SYSTEM_TYPE = 0x1c2;
private static final int OFF_END_HEAD = 0x1c3;
private static final int OFF_END_SECTOR = 0x1c4;
private static final int OFF_END_CYLINDER = 0x1c5;
private static final int OFF_REL_SECTORS = 0x1c6;
private static final int OFF_NUMBER_OF_SECTORS = 0x1ca;
private static final int OFF_PARTITION_SIG = 0x1fe;
// Lengths of some of the fields
private static final int LEN_MAP_NAME_CONT = 30;
private static final int LEN_MAP_DESCRIPTION = 20;
private FileSystemParam fsParams;
private final ByteBuffer header = ByteBuffer.allocate(512);
private ImgChannel file;
private Date creationTime;
private int sectorsPerTrack;
private int headsPerCylinder;
// Signatures.
private static final byte[] FILE_ID = {
'G', 'A', 'R', 'M', 'I', 'N', '\0'};
private static final byte[] SIGNATURE = {
'D', 'S', 'K', 'I', 'M', 'G', '\0'};
private int numBlocks;
ImgHeader(ImgChannel chan) {
this.file = chan;
header.order(ByteOrder.LITTLE_ENDIAN);
}
/**
* Create a header from scratch.
* @param params File system parameters.
*/
void createHeader(FileSystemParam params) {
this.fsParams = params;
header.put(OFF_XOR, (byte) 0);
// Set the block size. 2^(E1+E2) where E1 is always 9.
int exp = 9;
int bs = params.getBlockSize();
for (int i = 0; i < 32; i++) {
bs >>>= 1;
if (bs == 0) {
exp = i;
break;
}
}
if (exp < 9)
throw new IllegalArgumentException("block size too small");
header.put(OFF_BLOCK_SIZE_EXPONENT1, (byte) 0x9);
header.put(OFF_BLOCK_SIZE_EXPONENT2, (byte) (exp - 9));
header.position(OFF_SIGNATURE);
header.put(SIGNATURE);
header.position(OFF_MAP_FILE_INTENTIFIER);
header.put(FILE_ID);
header.put(OFF_UNK_1, (byte) 0x2);
// Actually this may not be the directory start block, I am guessing -
// always assume it is 2 anyway.
header.put(OFF_DIRECTORY_START_BLOCK, (byte) fsParams.getDirectoryStartEntry());
header.position(OFF_CREATION_DATE);
Utils.setCreationTime(header, creationTime);
setDirectoryStartEntry(params.getDirectoryStartEntry());
// Set the times.
Date date = new Date();
setCreationTime(date);
setUpdateTime(date);
setDescription(params.getMapDescription());
// Checksum is not checked.
header.put(OFF_CHECKSUM, (byte) 0);
}
/**
* Write out the values associated with the partition sizes.
*
* @param blockSize Block size.
*/
private void writeSizeValues(int blockSize) {
int endSector = (int) (((numBlocks+1L) * blockSize + 511) / 512);
//System.out.printf("end sector %d %x\n", endSector, endSector);
// We have three maximum values for sectors, heads and cylinders. We attempt to find values
// for them that are larger than the
sectorsPerTrack = 32; // 6 bit value
headsPerCylinder = 128;
int cyls = 0x400;
// Try out various values of h, s and c until we find a combination that is large enough.
// I'm not entirely sure about the valid values, but it seems that only certain values work
// which is why we use values from a list.
// See: http://www.win.tue.nl/~aeb/partitions/partition_types-2.html for justification for the h list
out:
for (int h : asList(16, 32, 64, 128, 256)) {
for (int s : asList(4, 8, 16, 32)) {
for (int c : asList(0x20, 0x40, 0x80, 0x100, 0x200, 0x3ff)) {
log.info("shc=", s + "," + h + "," + c, "end=", endSector);
//System.out.println("shc=" + s + "," + h + "," + c + "end=" + endSector);
if (s * h * c > endSector) {
headsPerCylinder = h;
sectorsPerTrack = s;
cyls = c;
break out;
}
}
}
}
// This sectors, head, cylinders stuff appears to be used by mapsource
// and they have to be larger than the actual size of the map. It
// doesn't appear to have any effect on a garmin device or other software.
header.putShort(OFF_SECTORS, (short) sectorsPerTrack);
header.putShort(OFF_SECTORS2, (short) sectorsPerTrack);
header.putShort(OFF_HEADS, (short) headsPerCylinder);
header.putShort(OFF_HEADS2, (short) headsPerCylinder);
header.putShort(OFF_CYLINDERS, (short) cyls);
// Since there are only 2 bytes here it can overflow, if it
// does we replace it with 0xffff.
int blocks = (int) (endSector * 512L / blockSize);
char shortBlocks = blocks > 0xffff ? 0xffff : (char) blocks;
header.putChar(OFF_BLOCK_SIZE, shortBlocks);
header.put(OFF_PARTITION_SIG, (byte) 0x55);
header.put(OFF_PARTITION_SIG + 1, (byte) 0xaa);
// Partition starts at zero. This is 0,0,1 in CHS terms.
header.put(OFF_START_HEAD, (byte) 0);
header.put(OFF_START_SECTOR, (byte) 1);
header.put(OFF_START_CYLINDER, (byte) 0);
header.put(OFF_SYSTEM_TYPE, (byte) 0);
// Now calculate the CHS address of the last sector of the partition.
CHS chs = new CHS(endSector - 1);
header.put(OFF_END_HEAD, (byte) (chs.h));
header.put(OFF_END_SECTOR, (byte) ((chs.s) | ((chs.c >> 2) & 0xc0)));
header.put(OFF_END_CYLINDER, (byte) (chs.c & 0xff));
// Write the LBA block address of the beginning and end of the partition.
header.putInt(OFF_REL_SECTORS, 0);
header.putInt(OFF_NUMBER_OF_SECTORS, endSector);
log.info("number of blocks", endSector - 1);
}
void setHeader(ByteBuffer buf) {
buf.flip();
header.put(buf);
byte exp1 = header.get(OFF_BLOCK_SIZE_EXPONENT1);
byte exp2 = header.get(OFF_BLOCK_SIZE_EXPONENT2);
log.debug("header exponent", exp1, exp2);
fsParams = new FileSystemParam();
fsParams.setBlockSize(1 << (exp1 + exp2));
fsParams.setDirectoryStartEntry(header.get(OFF_DIRECTORY_START_BLOCK));
StringBuffer sb = new StringBuffer();
sb.append(Utils.bytesToString(buf, OFF_MAP_DESCRIPTION, LEN_MAP_DESCRIPTION));
sb.append(Utils.bytesToString(buf, OFF_MAP_NAME_CONT, LEN_MAP_NAME_CONT));
fsParams.setMapDescription(sb.toString().trim());
byte h = header.get(OFF_END_HEAD);
byte sc1 = header.get(OFF_END_SECTOR);
byte sc2 = header.get(OFF_END_CYLINDER);
CHS chs = new CHS();
chs.setFromPartition(h, sc1, sc2);
int lba = chs.toLba();
log.info("partition sectors", lba);
// ... more to do
}
void setFile(ImgChannel file) {
this.file = file;
}
FileSystemParam getParams() {
return fsParams;
}
/**
* Sync the header to disk.
* @throws IOException If an error occurs during writing.
*/
public void sync() throws IOException {
setUpdateTime(new Date());
writeSizeValues(fsParams.getBlockSize());
header.rewind();
file.position(0);
file.write(header);
file.position(fsParams.getDirectoryStartEntry() * 512L);
}
/**
* Set the update time.
* @param date The date to use.
*/
protected void setUpdateTime(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
header.put(OFF_UPDATE_YEAR, toYearCode(cal.get(Calendar.YEAR)));
header.put(OFF_UPDATE_MONTH, (byte) (cal.get(Calendar.MONTH)+1));
}
/**
* Set the description. It is spread across two areas in the header.
* @param desc The description.
*/
protected void setDescription(String desc) {
int len = desc.length();
if (len > 50)
throw new IllegalArgumentException("Description is too long (max 50)");
String part1, part2;
if (len > LEN_MAP_DESCRIPTION) {
part1 = desc.substring(0, LEN_MAP_DESCRIPTION);
part2 = desc.substring(LEN_MAP_DESCRIPTION, len);
} else {
part1 = desc.substring(0, len);
part2 = "";
}
header.position(OFF_MAP_DESCRIPTION);
header.put(toByte(part1));
for (int i = len; i < LEN_MAP_DESCRIPTION; i++)
header.put((byte) ' ');
header.position(OFF_MAP_NAME_CONT);
header.put(toByte(part2));
for (int i = Math.max(len - LEN_MAP_DESCRIPTION, 0); i < LEN_MAP_NAME_CONT; i++)
header.put((byte) ' ');
header.put((byte) 0); // really?
}
/**
* Convert a string to a byte array.
* @param s The string
* @return A byte array.
*/
private byte[] toByte(String s) {
// NB: what character set should be used?
return s.getBytes();
}
/**
* Convert to the one byte code that is used for the year.
* If the year is in the 1900, then subtract 1900 and add the result to 0x63,
* else subtract 2000.
* Actually looks simpler, just subtract 1900..
* @param y The year in real-world format eg 2006.
* @return A one byte code representing the year.
*/
private byte toYearCode(int y) {
return (byte) (y - 1900);
}
protected void setDirectoryStartEntry(int directoryStartEntry) {
header.put(OFF_DIRECTORY_START_BLOCK, (byte) directoryStartEntry);
fsParams.setDirectoryStartEntry(directoryStartEntry);
}
protected void setCreationTime(Date date) {
this.creationTime = date;
}
public void setNumBlocks(int numBlocks) {
this.numBlocks = numBlocks;
}
/**
* Represent a block number in the chs format.
*
* Note that this class uses the headsPerCylinder and sectorsPerTrack values
* from the enclosing class.
*
* @see Logical block addressing
*/
private class CHS {
private int h;
private int s;
private int c;
private CHS() {
}
public CHS(int lba) {
toChs(lba);
}
/**
* Calculate the CHS values from the the given logical block address.
* @param lba Input logical block address.
*/
private void toChs(int lba) {
h = (lba / sectorsPerTrack) % headsPerCylinder;
s = (lba % sectorsPerTrack) + 1;
c = lba / (sectorsPerTrack * headsPerCylinder);
}
/**
* Set from a partition table entry.
*
* The cylinder is 10 bits and is split between the top 2 bit of the sector
* value and its own byte.
*
* @param h The h value.
* @param sc1 The s value (6 bits) and top 2 bits of c.
* @param sc2 The bottom 8 bits of c.
*/
public void setFromPartition(byte h, byte sc1, byte sc2) {
this.h = h;
this.s = (sc1 & 0x3f) + ((sc2 >> 2) & 0xc0);
this.c = sc2 & 0xff;
}
public int toLba() {
return (c * headsPerCylinder + h) * sectorsPerTrack + (s - 1);
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/sys/HeaderDirent.java 0000644 0000764 0000764 00000004052 11511612275 023052 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 27-Oct-2007
*/
package uk.me.parabola.imgfmt.sys;
/**
* This is a special class for the header. It makes it easier to bootstrap
* the directory by having a special implementation that starts up by knowing
* that the blocks in the header start from 0.
*
* @author Steve Ratcliffe
*/
class HeaderDirent extends Dirent {
HeaderDirent(String name, BlockManager blockManager) {
super(name, blockManager);
}
/**
* Converts from a logical block to a physical block. This is a special
* version that returns the logical block number when the {@link Dirent} is not
* set up. This allows us to bootstrap the reading of the header blocks.
* The header blocks always logical and physical blocks the same.
*
* @param lblock The logical block in the file.
* @return The corresponding physical block in the filesystem.
*/
public int getPhysicalBlock(int lblock) {
if (isInitialized()) {
log.debug("gpb (ok)");
return super.getPhysicalBlock(lblock);
} else {
log.debug("gpb (not setup)");
return lblock;
}
}
/**
* Get the file size. The file appears large until the first blocks are
* read in and then it will take on its actual size.
*
* @return The size of the file in bytes.
*/
public int getSize() {
if (isInitialized())
return super.getSize();
else
return getBlockManager().getBlockSize() * 32;
}
/**
* Always returns true as this is only used for the special header
* directory entry.
*
* @return Always returns true.
*/
public boolean isSpecial() {
return true;
}
} mkgmap-r3660/src/uk/me/parabola/imgfmt/FileExistsException.java 0000644 0000764 0000764 00000002227 10666506051 023642 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 02-Dec-2006
*/
package uk.me.parabola.imgfmt;
import java.io.IOException;
/**
* Thrown when a file already exists and would be overwritten.
*
* @author Steve Ratcliffe
*/
public class FileExistsException extends IOException {
/**
* Constructs a new exception with the specified detail message. The
* cause is not initialized, and may subsequently be initialized by
* a call to {@link #initCause}.
*
* @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public FileExistsException(String message) {
super(message);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/ReadFailedException.java 0000644 0000764 0000764 00000002536 10766754612 023557 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 14, 2007
*/
package uk.me.parabola.imgfmt;
/**
* @author Steve Ratcliffe
*/
public class ReadFailedException extends RuntimeException {
/**
* Constructs a new runtime exception with the specified detail message and
* cause. Note that the detail message associated with cause
* is not automatically incorporated in this runtime exception's detail
* message.
*
* @param message the detail message (which is saved for later retrieval by the
* {@link #getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the {@link
* #getCause()} method). (A null value is permitted, and indicates
* that the cause is nonexistent or unknown.)
* @since 1.4
*/
public ReadFailedException(String message, Throwable cause) {
super(message, cause);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/ 0000755 0000764 0000764 00000000000 12651103763 017634 5 ustar steve steve mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/Block.java 0000644 0000764 0000764 00000004006 11110050256 021514 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 19, 2007
*/
package uk.me.parabola.imgfmt.mps;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.io.StructuredOutputStream;
/**
* All the blocks in the file have a type and a length.
*
* @author Steve Ratcliffe
*/
public abstract class Block {
private final int type;
private final ByteArrayOutputStream output = new ByteArrayOutputStream();
protected Block(int type) {
this.type = type;
}
public void write(ImgChannel chan) throws IOException {
// First write the body to the byte buffer so that we know its length.
writeBody(new StructuredOutputStream(output));
ByteBuffer buf = ByteBuffer.allocate(16);
buf.order(ByteOrder.LITTLE_ENDIAN);
buf.put((byte) type);
char len = getLength();
buf.putChar(len);
// write the header.
buf.flip();
chan.write(buf);
// write the body.
buf = ByteBuffer.allocate(len);
buf.put(output.toByteArray());
buf.flip();
chan.write(buf);
}
/**
* Writes the body to the output stream given.
*
* @param out The stream to write to.
*/
protected abstract void writeBody(StructuredOutputStream out) throws IOException;
/**
* This is only valid after everything is written to the block.
*
* @return The length of the block (or the amount written already).
*/
private char getLength() {
int len = output.toByteArray().length;
assert len <= 0xffff;
return (char) len;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/MapsetBlock.java 0000644 0000764 0000764 00000002155 10763340724 022710 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 19, 2007
*/
package uk.me.parabola.imgfmt.mps;
import uk.me.parabola.io.StructuredOutputStream;
import java.io.IOException;
/**
* Block describing the map set.
*
* @author Steve Ratcliffe
*/
public class MapsetBlock extends Block {
private static final int BLOCK_TYPE = 0x56;
private String name = "OSM map set";
public MapsetBlock() {
super(BLOCK_TYPE);
}
protected void writeBody(StructuredOutputStream out) throws IOException {
out.writeString(name);
out.write(0); // unknown
}
public void setName(String name) {
if (name != null)
this.name = name;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/MpsFile.java 0000644 0000764 0000764 00000003575 11315746733 022056 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 19, 2007
*/
package uk.me.parabola.imgfmt.mps;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import uk.me.parabola.imgfmt.fs.ImgChannel;
/**
* This file is a description of the map set that is loaded into the
* gmapsupp.img file and an index of the maps that it contains.
*
* It is different than all the other files that fit inside the gmapsupp file
* in that it doesn't contain the common header. So it does not extend ImgFile.
*
* @author Steve Ratcliffe
*/
public class MpsFile {
private String mapsetName = "OSM map set";
private final Set products = new HashSet();
private final List maps = new ArrayList();
private final ImgChannel chan;
public MpsFile(ImgChannel chan) {
this.chan = chan;
}
public void sync() throws IOException {
for (MapBlock map : maps)
map.write(chan);
for (ProductBlock block : products)
block.write(chan);
MapsetBlock mapset = new MapsetBlock();
mapset.setName(mapsetName);
mapset.write(chan);
}
public void addMap(MapBlock map) {
maps.add(map);
}
public void addProduct(ProductBlock pb) {
products.add(pb);
}
public void setMapsetName(String mapsetName) {
this.mapsetName = mapsetName;
}
public void close() throws IOException {
chan.close();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/MpsFileReader.java 0000644 0000764 0000764 00000005232 12075561467 023174 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 19, 2007
*/
package uk.me.parabola.imgfmt.mps;
import java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.BufferedImgFileReader;
import uk.me.parabola.imgfmt.app.ImgFileReader;
import uk.me.parabola.imgfmt.fs.ImgChannel;
/**
* This file is a description of the map set that is loaded into the
* gmapsupp.img file and an index of the maps that it contains.
*
* It is different than all the other files that fit inside the gmapsupp file
* in that it doesn't contain the common header. So it does not extend ImgFile.
*
* @author Steve Ratcliffe
*/
public class MpsFileReader implements Closeable {
private final List maps = new ArrayList();
private final List products = new ArrayList();
private final ImgChannel chan;
private final ImgFileReader reader;
public MpsFileReader(ImgChannel chan) {
this.chan = chan;
this.reader = new BufferedImgFileReader(chan);
readBlocks();
}
private void readBlocks() {
byte type;
while ((type = reader.get()) > 0) {
int len = reader.getChar();
switch (type) {
case 0x4c:
readMapBlock();
break;
case 0x46:
readProductBlock();
break;
default:
// We always know the length, so just read over it
reader.get(len);
break;
}
}
}
private void readMapBlock() {
MapBlock block = new MapBlock();
int val = reader.getInt();
block.setIds(val >>> 16, val & 0xffff);
block.setMapNumber(reader.getInt());
block.setSeriesName(reader.getZString());
block.setMapDescription(reader.getZString());
block.setAreaName(reader.getZString());
block.setHexNumber(reader.getInt());
reader.getInt();
maps.add(block);
}
private void readProductBlock() {
ProductBlock block = new ProductBlock();
block.setProductId(reader.getChar());
block.setFamilyId(reader.getChar());
block.setDescription(reader.getZString());
products.add(block);
}
public List getMaps() {
return maps;
}
public List getProducts() {
return products;
}
public void close() throws IOException {
chan.close();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/MapBlock.java 0000644 0000764 0000764 00000004373 11532723256 022200 0 ustar steve steve /*
* Copyright (C) 2007,2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.mps;
import java.io.IOException;
import uk.me.parabola.io.StructuredOutputStream;
/**
* A block describing an individual map.
*
* The family id, product id, series name, area name and map description can
* be set per map.
*
* @author Steve Ratcliffe
*/
public class MapBlock extends Block {
private static final int BLOCK_TYPE = 0x4c;
private int familyId;
private int productId;
private int mapNumber;
private int hexNumber;
private String seriesName;
private String mapDescription;
private String areaName;
public MapBlock() {
super(BLOCK_TYPE);
}
protected void writeBody(StructuredOutputStream out) throws IOException {
out.write2(productId);
out.write2(familyId);
out.write4(mapNumber);
out.writeString(seriesName);
out.writeString(mapDescription);
out.writeString(areaName);
out.write4(hexNumber);
out.write4(0);
}
public void setIds(int familyId, int productId) {
this.familyId = familyId;
this.productId = productId;
}
public void setSeriesName(String seriesName) {
this.seriesName = seriesName;
}
public void setMapNumber(int mapNumber) {
this.mapNumber = mapNumber;
}
public void setHexNumber(int hexNumber) {
this.hexNumber = hexNumber;
}
public void setMapDescription(String mapDescription) {
this.mapDescription = mapDescription;
}
public void setAreaName(String areaName) {
this.areaName = areaName;
}
public int getFamilyId() {
return familyId;
}
public int getProductId() {
return productId;
}
public int getMapNumber() {
return mapNumber;
}
public int getHexNumber() {
return hexNumber;
}
public String getSeriesName() {
return seriesName;
}
public String getMapDescription() {
return mapDescription;
}
public String getAreaName() {
return areaName;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/ProductBlock.java 0000644 0000764 0000764 00000003676 11315746733 023114 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 19, 2007
*/
package uk.me.parabola.imgfmt.mps;
import java.io.IOException;
import uk.me.parabola.io.StructuredOutputStream;
/**
* A block describing a particular product. Not sure how this relates
* to the map set.
*
* @author Steve Ratcliffe
*/
public class ProductBlock extends Block {
private static final int BLOCK_TYPE = 0x46;
private int familyId;
private int productId;
private String description = "OSM maps";
public ProductBlock() {
super(BLOCK_TYPE);
}
protected void writeBody(StructuredOutputStream out) throws IOException {
out.write2(productId);
out.write2(familyId);
out.writeString(description);
}
public void setFamilyId(int familyId) {
this.familyId = familyId;
}
public int getFamilyId() {
return familyId;
}
public void setProductId(int productId) {
this.productId = productId;
}
public int getProductId() {
return productId;
}
public void setDescription(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ProductBlock that = (ProductBlock) o;
if (familyId != that.familyId) return false;
if (productId != that.productId) return false;
return true;
}
public int hashCode() {
int result = familyId;
result = 31 * result + productId;
return result;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/mps/package.html 0000644 0000764 0000764 00000001563 12152046274 022121 0 ustar steve steve
The MPS file
This file is similar to the TDB file in that it is a list of maps along with
other information describing the set. It is inserted into the gmapsupp.img
file.
A map will work without this file, but it is essential when you have maps from different
families loaded together as it allows you to see the names of the map
families and turn them on and off separately.
It isn't like the other files in the app package, in that it doesn't
begin with the common header. It should perhaps live with the TDB format or
in a similar top level place. It is here because it is included inside the
gmapsupp.img file and doesn't normally have a separate existance.
The names and lengths of the fields were obtained from the program gpsexplorer
by the author identified as 'garminmaploader@yahoo.com' and released under
GPL2+.
mkgmap-r3660/src/uk/me/parabola/imgfmt/FileNotWritableException.java 0000644 0000764 0000764 00000001677 11000461742 024613 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 02-Sep-2007
*/
package uk.me.parabola.imgfmt;
import java.io.IOException;
/**
* If a file cannot be created, or written to, then this exception is thrown.
* @author Steve Ratcliffe
*/
public class FileNotWritableException extends IOException {
public FileNotWritableException(String s, Exception e) {
// super class does not have the constructor that takes an exception
super(s + ' ' + e.getMessage());
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/ 0000755 0000764 0000764 00000000000 12651103763 017615 5 ustar steve steve mkgmap-r3660/src/uk/me/parabola/imgfmt/app/ImgReader.java 0000644 0000764 0000764 00000002432 11400726372 022316 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app;
import java.io.Closeable;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.util.Configurable;
/**
* Base class for all the img sub file reading classes.
*
* @author Steve Ratcliffe
*/
public abstract class ImgReader implements Closeable, Configurable {
private CommonHeader header;
private ImgFileReader reader;
public void close() {
Utils.closeFile(reader);
}
protected long position() {
return reader.position();
}
protected void position(long pos) {
reader.position(pos);
}
public CommonHeader getHeader() {
return header;
}
protected final void setHeader(CommonHeader header) {
this.header = header;
}
protected ImgFileReader getReader() {
return reader;
}
protected void setReader(ImgFileReader reader) {
this.reader = reader;
}
} mkgmap-r3660/src/uk/me/parabola/imgfmt/app/ImgFileReader.java 0000644 0000764 0000764 00000005754 11532723256 023134 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 07-Dec-2006
*/
package uk.me.parabola.imgfmt.app;
import java.io.Closeable;
import uk.me.parabola.imgfmt.ReadFailedException;
/**
* For reading subfiles from the img. The focus of mkgmap is on writing,
* but some limited reading is needed for several operations.
*
* @author Steve Ratcliffe
*/
public interface ImgFileReader extends Closeable {
/**
* Get the position. Needed because may not be reflected in the underlying
* file if being buffered.
*
* @return The logical position within the file.
*/
public long position();
/**
* Set the position of the file.
* @param pos The new position in the file.
*/
void position(long pos);
/**
* Read in a single byte.
* @return The byte that was read.
*/
public byte get() throws ReadFailedException;
/**
* Read in two bytes. Done in the correct byte order.
* @return The 2 byte integer that was read.
*/
public char getChar() throws ReadFailedException;
/**
* Get a 3byte signed quantity.
*
* @return The value read.
* @throws ReadFailedException When the file cannot be read.
*/
public int get3() throws ReadFailedException;
/**
* Get a 3byte unsigned quantity.
*
* @return The value read.
* @throws ReadFailedException When the file cannot be read.
*/
public int getu3() throws ReadFailedException;
/**
* Read in a 4 byte value.
* @return A 4 byte integer.
*/
public int getInt() throws ReadFailedException;
/**
* Read a variable sized integer. The size is given.
* @param n The size of the integer to read. Must be 1 to 4.
* @return The integer which will not be sign extended if it is less
* than 4 bytes long.
*/
public int getUint(int n) throws ReadFailedException;
/**
* Read in an arbitrary length sequence of bytes.
*
* @param len The number of bytes to read.
*/
public byte[] get(int len) throws ReadFailedException;
/**
* Read a zero terminated string from the file.
* @return A string
* @throws ReadFailedException For failures.
*/
public String getZString() throws ReadFailedException;
/**
* Read in a string of digits in the compressed base 11 format that is used
* for phone numbers in the POI section.
* @param delimiter This will replace all digit 11 characters. Usually a
* '-' to separate numbers in a telephone. No doubt there is a different
* standard in each country.
* @return A phone number possibly containing the delimiter character.
*/
public String getBase11str(byte firstChar, char delimiter);
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/FileBackedImgFileWriter.java 0000644 0000764 0000764 00000012651 11642611367 025073 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import uk.me.parabola.imgfmt.MapFailedException;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.fs.ImgChannel;
/**
* Write img file data to a temporary file. On a call to sync() the data
* is copied to the output channel.
*
* @author Steve Ratcliffe
*/
public class FileBackedImgFileWriter implements ImgFileWriter{
private final ImgChannel outputChan;
private final File tmpFile;
private final BufferedOutputStream file;
private final FileChannel tmpChannel;
public FileBackedImgFileWriter(ImgChannel chan, File outputDir) {
this.outputChan = chan;
try {
tmpFile = File.createTempFile("img", null, outputDir);
tmpFile.deleteOnExit();
FileOutputStream out = new FileOutputStream(tmpFile);
tmpChannel = out.getChannel();
file = new BufferedOutputStream(out, 16*1024);
} catch (IOException e) {
throw new MapFailedException("Could not create mdr temporary file");
}
}
/**
* Maps the temporary file and copies to the output channel.
*
* @throws IOException If there is an error writing.
*/
public void sync() throws IOException {
file.close();
FileInputStream is = null;
try {
is = new FileInputStream(tmpFile);
FileChannel channel = is.getChannel();
channel.transferTo(0, channel.size(), outputChan);
channel.close();
} finally {
Utils.closeFile(is);
if (!tmpFile.delete())
System.err.println("Could not delete mdr img temporary file");
}
}
/**
* Get the position. Have to flush the buffer before getting the position.
*
* @return The logical position within the file.
*/
public int position() {
try {
file.flush();
return (int) tmpChannel.position();
} catch (IOException e) {
return 0;
}
}
/**
* Set the position of the file.
* The buffer has to be flushed first.
*
* @param pos The new position in the file.
*/
public void position(long pos) {
try {
file.flush();
tmpChannel.position(pos);
} catch (IOException e) {
throw new MapFailedException("Could not set position in mdr tmp file");
}
}
/**
* Write out a single byte.
*
* @param b The byte to write.
*/
public void put(byte b) {
try {
file.write(b);
} catch (IOException e) {
throw new MapFailedException("could not write byte to mdr tmp file");
}
}
/**
* Write out two bytes. Can't use writeChar() since need to reverse the byte
* order.
*
* @param c The value to write.
*/
public void putChar(char c) {
try {
file.write(c);
file.write(c >> 8);
} catch (IOException e) {
throw new MapFailedException("could not write char to mdr tmp file");
}
}
/**
* Write out three bytes. Done in the little endian byte order.
*
* @param val The value to write, only the bottom three bytes will be written.
*/
public void put3(int val) {
try {
file.write(val);
file.write(val >> 8);
file.write(val >> 16);
} catch (IOException e) {
throw new MapFailedException("could not write3 to mdr tmp file");
}
}
/**
* Write out 4 byte value.
*
* @param val The value to write.
*/
public void putInt(int val) {
try {
file.write(val);
file.write(val >> 8);
file.write(val >> 16);
file.write(val >> 24);
} catch (IOException e) {
throw new MapFailedException("could not write int to mdr tmp file");
}
}
/**
* Write out an arbitrary length sequence of bytes.
*
* @param val The values to write.
*/
public void put(byte[] val) {
try {
file.write(val);
} catch (IOException e) {
throw new MapFailedException("could not write bytes to mdr tmp file");
}
}
/**
* Write out part of a byte array.
*
* @param src The array to take bytes from.
* @param start The start position.
* @param length The number of bytes to write.
*/
public void put(byte[] src, int start, int length) {
try {
file.write(src, start, length);
} catch (IOException e) {
throw new MapFailedException("could not write bytes to mdr tmp file");
}
}
/**
* Write out a complete byte buffer.
*
* @param src The buffer to write.
*/
public void put(ByteBuffer src) {
try {
file.flush();
tmpChannel.write(src);
} catch (IOException e) {
throw new MapFailedException("could not write buffer to mdr tmp file");
}
}
/**
* Returns the size of the file.
*
* @return The file size in bytes.
*/
public long getSize() {
try {
file.flush();
return tmpChannel.size();
} catch (IOException e) {
throw new MapFailedException("could not get size of mdr tmp file");
}
}
/**
* Closes this stream and releases any system resources associated with it. If the stream is already closed then
* invoking this method has no effect.
*
* @throws IOException if an I/O error occurs
*/
public void close() throws IOException {
outputChan.close();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/ 0000755 0000764 0000764 00000000000 12651103763 020431 5 ustar steve steve mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypPoint.java 0000644 0000764 0000764 00000003712 11665675646 023107 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import java.nio.charset.CharsetEncoder;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Represents a POI in the typ file.
*
* @author Steve Ratcliffe
*/
public class TypPoint extends TypElement {
private Xpm nightXpm;
private static final byte F_BITMAP = 0x1;
private static final byte F_NIGHT_XPM = 0x2;
private static final byte F_LABEL = 0x4;
private static final byte F_EXTENDED_FONT = 0x8;
public void write(ImgFileWriter writer, CharsetEncoder encoder) {
offset = writer.position();
byte flags = F_BITMAP;
if (nightXpm != null)
flags |= F_NIGHT_XPM;
if (!labels.isEmpty())
flags |= F_LABEL;
if (fontStyle != 0 || dayFontColour != null || nightFontColour != null)
flags |= F_EXTENDED_FONT;
writer.put(flags);
// Width and height is the same for day and night images, so it is written once only.
ColourInfo colourInfo = xpm.getColourInfo();
writer.put((byte) colourInfo.getWidth());
writer.put((byte) colourInfo.getHeight());
// Day or only image
writeImage(writer, xpm);
if ((flags & F_NIGHT_XPM) != 0)
writeImage(writer, nightXpm);
if ((flags & F_LABEL) != 0)
writeLabelBlock(writer, encoder);
if ((flags & F_EXTENDED_FONT) != 0)
writeExtendedFontInfo(writer);
}
public void setNightXpm(Xpm nightXpm) {
this.nightXpm = nightXpm;
}
/**
* Points have full pixmaps with multiple colours, including 24 full colour images.
*/
public boolean simpleBitmap() {
return false;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/ShapeStacking.java 0000644 0000764 0000764 00000003137 11670361040 024016 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 15, 2007
*/
package uk.me.parabola.imgfmt.app.typ;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Holds the shape stacking section.
*
* Deals with sorting everything correctly, so no need to sort in the input file.
*
* @author Steve Ratcliffe
*/
public class ShapeStacking {
private final SortedMap bar = new TreeMap();
public void addPolygon(int level, int type, int subtype) {
int levelType = (level << 16) + type;
DrawOrder order = bar.get(levelType);
if (order == null) {
order = new DrawOrder(type);
bar.put(levelType, order);
}
order.addSubtype(subtype);
}
public void write(ImgFileWriter writer) {
int lastLevel = 1;
DrawOrder empty = new DrawOrder(0);
for (Map.Entry ent : bar.entrySet()) {
int level = (ent.getKey() >> 16) & 0xffff;
DrawOrder order = ent.getValue();
if (level != lastLevel) {
empty.write(writer);
lastLevel = level;
}
order.write(writer);
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TrueImage.java 0000644 0000764 0000764 00000006754 11711515370 023167 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import uk.me.parabola.imgfmt.app.BitWriter;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* A true colour image.
*
* The image is represented by an array of int, with each int in RGBA format.
*
* @author Steve Ratcliffe
*/
public class TrueImage implements Image {
private final ColourInfo colourInfo;
private final int[] image;
// If this is mode 16, then the transparent colour is set.
private int transparentPixel;
public TrueImage(ColourInfo colourInfo, int[] image) {
analyzeColours(image, colourInfo);
this.colourInfo = colourInfo;
this.image = image;
}
/**
* Write out the image. It is a set of pixel values that are full RGB values, rather than
* table driven as in the other image type. If the colour mode is 32 the colours have an
* extra 4 bit opacity value following.
*
* If the colour mode is 16, then the transparent pixel is written just before the image
* itself.
*/
public void write(ImgFileWriter writer) {
int width = colourInfo.getWidth();
int height = colourInfo.getHeight();
int mode = colourInfo.getColourMode();
// For mode 16, the transparent pixel precedes the pixmap data.
if (mode == 16) {
writer.put((byte) (transparentPixel>>8));
writer.put((byte) (transparentPixel>>16));
writer.put((byte) (transparentPixel>>24));
}
boolean hasAlpha = mode == 32;
// Unlike the xpm based images, the true-colour image format does not appear to
// have any padding so write as a continuous block.
BitWriter bitWriter = new BitWriter();
for (int h = 0; h < height; h++) {
for (int w = 0; w < width; w++) {
int col = image[h * width + w];
bitWriter.putn(col>>8 & 0xff, 8);
bitWriter.putn(col>>16 & 0xff, 8);
bitWriter.putn(col>>24 & 0xff, 8);
if (hasAlpha) {
int alpha = 0xff - (col & 0xff);
alpha = ColourInfo.alphaRound4(alpha);
bitWriter.putn(alpha, 4);
}
}
}
writer.put(bitWriter.getBytes(), 0, bitWriter.getLength());
}
/**
* Analyze the colours and determine if this should be a mode 16 or 32 image.
*
* By default it will be a mode 0 image. If there is any transparency the appropriate
* colour mode will be selected.
*
* @param image An images as an array of integers. Each integer is a colour in RGBA format.
* @param colourInfo The colour mode will be set in this.
*/
private void analyzeColours(int[] image, ColourInfo colourInfo) {
boolean hasTransparent = false;
boolean hasAlpha = false;
int nPixels = colourInfo.getWidth() * colourInfo.getHeight();
for (int i = 0; i < nPixels; i++) {
int col = image[i];
int a = col & 0xff;
if (a == 0) {
// Completely transparent, change all transparent pixels to the same value
if (hasTransparent)
image[i] = transparentPixel;
else
transparentPixel = image[i];
hasTransparent = true;
} else if (a < 255) {
// Partially transparent
hasAlpha = true;
}
}
if (hasAlpha)
colourInfo.setColourMode(32);
else if (hasTransparent)
colourInfo.setColourMode(16);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TYPHeader.java 0000644 0000764 0000764 00000013111 11665675646 023100 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 14, 2007
*/
package uk.me.parabola.imgfmt.app.typ;
import uk.me.parabola.imgfmt.app.CommonHeader;
import uk.me.parabola.imgfmt.app.ImgFileReader;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Section;
/**
* The header for the TYP file.
*
* @author Thomas Lußnig
*/
public class TYPHeader extends CommonHeader {
public static final int HEADER_LEN = 0x9c; // 0x6e;
private char familyId;
private char productId;
private char codePage;
private final Section pointData = new Section();
private final Section lineData = new Section(pointData);
private final Section polygonData = new Section(lineData);
private final Section pointIndex = new Section(polygonData, (char) 2);
private final Section lineIndex = new Section(pointIndex, (char) 2);
private final Section polygonIndex = new Section(lineIndex, (char) 2);
private final Section shapeStacking = new Section(polygonIndex, (char) 5);
private final Section iconData = new Section(polygonIndex);
private final Section iconIndex = new Section(iconData, (char) 3);
private final Section labels = new Section(iconIndex);
private final Section stringIndex = new Section(labels);
private final Section typeIndex = new Section(stringIndex);
public TYPHeader() {
super(HEADER_LEN, "GARMIN TYP");
}
/**
* Read the rest of the header. Specific to the given file. It is guaranteed
* that the file position will be set to the correct place before this is
* called.
*
* @param reader The header is read from here.
*/
protected void readFileHeader(ImgFileReader reader) {
// Reset position for the real header reading code.
reader.position(COMMON_HEADER_LEN);
codePage = reader.getChar(); // 1252
pointData.setPosition(reader.getInt());
pointData.setSize(reader.getInt());
lineData.setPosition(reader.getInt());
lineData.setSize(reader.getInt());
polygonData.setPosition(reader.getInt());
polygonData.setSize(reader.getInt());
familyId = reader.getChar();
productId = reader.getChar();
pointIndex.setPosition(reader.getInt());
pointIndex.setItemSize(reader.getChar());
pointIndex.setSize(reader.getInt());
lineIndex.setPosition(reader.getInt());
lineIndex.setItemSize(reader.getChar());
lineIndex.setSize(reader.getInt());
polygonIndex.setPosition(reader.getInt());
polygonIndex.setItemSize(reader.getChar());
polygonIndex.setSize(reader.getInt());
shapeStacking.setPosition(reader.getInt());
shapeStacking.setItemSize(reader.getChar());
shapeStacking.setSize(reader.getInt());
}
/**
* Write the rest of the header. It is guaranteed that the writer will be set
* to the correct position before calling.
*
* This header appears to have a different layout to most other headers.
*
* @param writer The header is written here.
*/
protected void writeFileHeader(ImgFileWriter writer) {
writer.putChar(codePage);
pointData.writeSectionInfo(writer);
lineData.writeSectionInfo(writer);
polygonData.writeSectionInfo(writer);
writer.putChar(familyId);
writer.putChar(productId);
// Can't use Section.writeSectionInfo here as there is an unusual layout.
writeSectionInfo(writer, pointIndex);
writeSectionInfo(writer, lineIndex);
writeSectionInfo(writer, polygonIndex);
writeSectionInfo(writer, shapeStacking);
if (getHeaderLength() > 0x5b) {
writeSectionInfo(writer, iconIndex);
writer.put((byte) 0x13);
iconData.writeSectionInfo(writer);
writer.putInt(0);
}
if (getHeaderLength() > 0x6e) {
labels.writeSectionInfo(writer);
// not known, guessing. Different layout to other files.
writer.putInt(stringIndex.getItemSize());
writer.putInt(0x1b);
writer.putInt(stringIndex.getPosition());
writer.putInt(stringIndex.getSize());
writer.putInt(typeIndex.getItemSize());
writer.putInt(0x1b);
writer.putInt(typeIndex.getPosition());
writer.putInt(typeIndex.getSize());
writer.putChar((char) 0);
}
}
/**
* There is an unusual layout of the section pointers in the TYP file for the sections
* that have an item size.
*/
private void writeSectionInfo(ImgFileWriter writer, Section section) {
writer.putInt(section.getPosition());
writer.putChar(section.getItemSize());
writer.putInt(section.getSize());
}
void setCodePage(char codePage) {
this.codePage = codePage;
}
Section getPointData() {
return pointData;
}
void setFamilyId(char familyId) {
this.familyId = familyId;
}
void setProductId(char productId) {
this.productId = productId;
}
Section getPointIndex() {
return pointIndex;
}
Section getShapeStacking() {
return shapeStacking;
}
public Section getPolygonData() {
return polygonData;
}
public Section getPolygonIndex() {
return polygonIndex;
}
public Section getLineData() {
return lineData;
}
public Section getLineIndex() {
return lineIndex;
}
public Section getIconData() {
return iconData;
}
public Section getIconIndex() {
return iconIndex;
}
public Section getLabels() {
return labels;
}
public Section getStringIndex() {
return stringIndex;
}
public Section getTypeIndex() {
return typeIndex;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypLabel.java 0000644 0000764 0000764 00000002042 11665675646 023030 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
/**
* @author Steve Ratcliffe
*/
public class TypLabel {
private final int lang;
private final String text;
public TypLabel(String in) {
String[] split = in.split(",", 2);
int l;
String s;
try {
l = Integer.decode(split[0]);
s = split[1];
} catch (NumberFormatException e) {
l = 0;
s = in;
}
this.lang = l;
this.text = s;
}
public TypLabel(int lang, String text) {
this.lang = lang;
this.text = text;
}
public int getLang() {
return lang;
}
public String getText() {
return text;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypLabelException.java 0000644 0000764 0000764 00000001633 11665675646 024714 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
/**
* Used when a label cannot be converted. An error is thrown indicating a charset to try
* instead of the default system one.
*
* @author Steve Ratcliffe
*/
public class TypLabelException extends RuntimeException {
private String charsetName;
public TypLabelException(String charsetName) {
this.charsetName = charsetName;
}
public String getCharsetName() {
return charsetName;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypElement.java 0000644 0000764 0000764 00000012155 12072370014 023356 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Base routines and data used by points, lines and polygons.
*
* If fact they are all very similar, so there is very little extra in the
* subclasses apart from the write routine.
*
* @author Steve Ratcliffe
*/
public abstract class TypElement implements Comparable {
private int type;
private int subType;
protected final List labels = new ArrayList();
protected Xpm xpm;
protected int fontStyle;
protected Rgb dayFontColour;
protected Rgb nightFontColour;
protected int offset;
public void setType(int type) {
this.type = type;
}
public void setSubType(int subType) {
this.subType = subType;
}
public int getType() {
return type;
}
/**
* We sort these by type.
* Only the index needs to be sorted (probably) but we don't create the index separately.
*
* @param o The other object to compare against.
* @return The usual -1, 0, 1 for the other object being less than, equal, greater than than this.
*/
public int compareTo(TypElement o) {
int t1 = getTypeForFile();
int t2 = o.getTypeForFile();
if (t1 == t2)
return 0;
else if (t1 < t2)
return -1;
else
return 1;
}
/**
* Get the type in the format required for writing in the typ file sections.
*/
public int getTypeForFile() {
return (type << 5) | (subType & 0x1f);
}
public void addLabel(String text) {
labels.add(new TypLabel(text));
}
public void setXpm(Xpm xpm) {
this.xpm = xpm;
}
public void setFontStyle(int font) {
this.fontStyle = font;
}
public void setDayFontColor(String value) {
dayFontColour = new Rgb(value);
}
public void setNightCustomColor(String value) {
nightFontColour = new Rgb(value);
}
public abstract void write(ImgFileWriter writer, CharsetEncoder encoder);
public int getOffset() {
return offset;
}
/**
* Does this element have two colour bitmaps, with possible automatic night colours. For lines and polygons.
*
* Overridden for points and icons.
*/
public boolean simpleBitmap() {
return true;
}
/**
* Make the label block separately as we need its length before we write it out properly.
*
* @param encoder For encoding the strings as bytes.
* @return A byte buffer with position set to the length of the block.
*/
protected ByteBuffer makeLabelBlock(CharsetEncoder encoder) {
ByteBuffer out = ByteBuffer.allocate(256 * labels.size());
for (TypLabel tl : labels) {
out.put((byte) tl.getLang());
CharBuffer cb = CharBuffer.wrap(tl.getText());
try {
ByteBuffer buffer = encoder.encode(cb);
out.put(buffer);
} catch (CharacterCodingException ignore) {
String name = encoder.charset().name();
//System.out.println("cs " + name);
throw new TypLabelException(name);
}
out.put((byte) 0);
}
return out;
}
/**
* Write the label block, this is the same for all element types.
* @param encoder To properly encode the labels.
*/
protected void writeLabelBlock(ImgFileWriter writer, CharsetEncoder encoder) {
ByteBuffer out = makeLabelBlock(encoder);
int len = out.position();
// The length is encoded as a variable length integer with the length indicated by a suffix.
len = (len << 1) + 1;
int mask = ~0xff;
while ((len & mask) != 0) {
mask <<= 8;
len <<= 1;
}
// write out the length, I'm assuming that it will be 1 or 2 bytes
if (len > 0xff)
writer.putChar((char) len);
else
writer.put((byte) len);
// Prepare and write buffer
out.flip();
writer.put(out);
}
/**
* Write out extended font information, colour and size.
*
* This is the same for each element type.
*/
protected void writeExtendedFontInfo(ImgFileWriter writer) {
byte fontExt = (byte) fontStyle;
if (dayFontColour != null)
fontExt |= 0x8;
if (nightFontColour != null)
fontExt |= 0x10;
writer.put(fontExt);
if (dayFontColour != null)
dayFontColour.write(writer, (byte) 0x10);
if (nightFontColour != null)
nightFontColour.write(writer, (byte) 0x10);
}
/**
* Write out an image. The width and height are written separately, because they are not
* repeated for the night image.
*
* @param xpm Either the day or night XPM.
*/
protected void writeImage(ImgFileWriter writer, Xpm xpm) {
ColourInfo colourInfo = xpm.getColourInfo();
writer.put((byte) colourInfo.getNumberOfSColoursForCM());
writer.put((byte) colourInfo.getColourMode());
colourInfo.write(writer);
xpm.writeImage(writer);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/DrawOrder.java 0000644 0000764 0000764 00000001350 11670361040 023156 0 ustar steve steve package uk.me.parabola.imgfmt.app.typ;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Writeable;
/**
* The drawing order for a type and a set of subtypes.
*
* The drawing order is specified by the order of these within the file, rather than anything
* actually in the item.
*/
public class DrawOrder implements Writeable {
private final byte type;
private int subTypes;
private boolean hasSubtypes;
public DrawOrder(int type) {
this.type = (byte) (type & 0xff);
if (type >= 0x100)
hasSubtypes = true;
}
public void write(ImgFileWriter writer) {
writer.put(type);
writer.putInt(subTypes);
}
public void addSubtype(int subtype) {
if (hasSubtypes)
subTypes |= 1 << subtype;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypLine.java 0000644 0000764 0000764 00000005432 11665675646 022706 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import java.nio.charset.CharsetEncoder;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* A line as read from a typ.txt file.
*
* @author Steve Ratcliffe
*/
public class TypLine extends TypElement {
private static final int F_LABEL = 0x1;
private static final int F_USE_ROTATION = 0x2;
private static final int F_EXTENDED = 0x4;
private boolean useOrientation;
private byte lineWidth;
private byte borderWidth;
/**
* This is slightly different to the polygon case, but not much.
*
* The line width is held in the first byte along with the type.
* The colour scheme does not have a bit to say if a bitmap is used,
* as you can always have one.
*
* There is a border width that can be specified.
*
* @param encoder For the labels.
*/
public void write(ImgFileWriter writer, CharsetEncoder encoder) {
offset = writer.position();
byte flags = 0;
if (!labels.isEmpty())
flags |= F_LABEL;
if (fontStyle != 0 || dayFontColour != null)
flags |= F_EXTENDED;
if (!useOrientation)
flags |= F_USE_ROTATION;
int height = 0;
if (xpm.hasImage())
height = xpm.getColourInfo().getHeight();
ColourInfo colourInfo = xpm.getColourInfo();
int scheme = colourInfo.getColourScheme() & 0x7;
writer.put((byte) ((scheme & 0x7) | (height << 3)));
writer.put(flags);
colourInfo.write(writer);
if (xpm.hasImage())
xpm.writeImage(writer);
if (height == 0) {
writer.put(lineWidth);
if ((scheme&~1) != 6)
writer.put((byte) (lineWidth + 2*borderWidth));
}
// The labels have a length byte to show the number of bytes following. There is
// also a flag in the length. The strings have a language number proceeding them.
// The strings themselves are null terminated.
if ((flags & F_LABEL) != 0)
writeLabelBlock(writer, encoder);
// The extension section hold font style and colour information for the labels.
if ((flags & F_EXTENDED) != 0)
writeExtendedFontInfo(writer);
}
public void setUseOrientation(boolean useOrientation) {
this.useOrientation = useOrientation;
}
public void setLineWidth(int val) {
lineWidth = (byte) val;
}
public void setBorderWidth(int borderWidth) {
this.borderWidth = (byte) borderWidth;
}
public void finish() {
if (borderWidth != 0)
xpm.getColourInfo().setHasBorder(true);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TYPFile.java 0000644 0000764 0000764 00000015034 12072370014 022543 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 03-Dec-2006
* Change: Thomas Lußnig
*/
package uk.me.parabola.imgfmt.app.typ;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.app.BufferedImgFileWriter;
import uk.me.parabola.imgfmt.app.ImgFile;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Section;
import uk.me.parabola.imgfmt.app.SectionWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.log.Logger;
/**
* The TYP file.
*
* @author Thomas Lußnig
* @author Steve Ratcliffe
*/
public class TYPFile extends ImgFile {
private static final Logger log = Logger.getLogger(TYPFile.class);
private final TYPHeader header = new TYPHeader();
private TypData data;
private final Map strToType = new TreeMap();
private final Map typeToStr = new TreeMap();
public TYPFile(ImgChannel chan) {
setHeader(header);
setWriter(new BufferedImgFileWriter(chan));
position(TYPHeader.HEADER_LEN);
}
public void write() {
ImgFileWriter writer = getWriter();
writer.position(TYPHeader.HEADER_LEN);
writeSection(writer, header.getPolygonData(), header.getPolygonIndex(), data.getPolygons());
writeSection(writer, header.getLineData(), header.getLineIndex(), data.getLines());
writeSection(writer, header.getPointData(), header.getPointIndex(), data.getPoints());
SectionWriter subWriter = header.getShapeStacking().makeSectionWriter(writer);
data.getStacking().write(subWriter);
Utils.closeFile(subWriter);
writeSection(writer, header.getIconData(), header.getIconIndex(), data.getIcons());
writeLabels(writer);
writeStrIndex(writer);
writerTypeIndex(writer);
zapZero(header.getShapeStacking(), header.getLabels(), header.getStringIndex(), header.getTypeIndex());
log.debug("syncing TYP file");
position(0);
getHeader().writeHeader(getWriter());
}
private void writeLabels(ImgFileWriter in) {
if (data.getIcons().isEmpty())
return;
SectionWriter writer = header.getLabels().makeSectionWriter(in);
List> keys = new ArrayList>();
Sort sort = data.getSort();
for (TypIconSet icon : data.getIcons()) {
String label = icon.getLabel();
if (label != null) {
SortKey key = sort.createSortKey(icon, label);
keys.add(key);
}
}
Collections.sort(keys);
// Offset 0 is reserved to mean no label.
writer.put((byte) 0);
for (SortKey key : keys) {
int off = writer.position();
TypIconSet icon = key.getObject();
int type = icon.getTypeForFile();
String label = icon.getLabel();
if (label != null) {
CharBuffer cb = CharBuffer.wrap(label);
CharsetEncoder encoder = data.getEncoder();
try {
ByteBuffer buffer = encoder.encode(cb);
writer.put(buffer);
// If we succeeded then note offsets for indexes
strToType.put(off, type);
typeToStr.put(type, off);
} catch (CharacterCodingException ignore) {
String name = encoder.charset().name();
throw new TypLabelException(name);
}
writer.put((byte) 0);
}
}
Utils.closeFile(writer);
}
private void writeStrIndex(ImgFileWriter in) {
SectionWriter writer = header.getStringIndex().makeSectionWriter(in);
int psize = ptrSize(header.getLabels().getSize());
header.getStringIndex().setItemSize((char) (3 + psize));
for (Map.Entry ent : strToType.entrySet()) {
putN(writer, psize, ent.getKey());
putN(writer, 3, ent.getValue());
}
Utils.closeFile(writer);
}
private void writerTypeIndex(ImgFileWriter in) {
SectionWriter writer = header.getTypeIndex().makeSectionWriter(in);
int psize = ptrSize(header.getLabels().getSize());
header.getTypeIndex().setItemSize((char) (3 + psize));
for (Map.Entry ent : typeToStr.entrySet()) {
putN(writer, 3, ent.getKey());
putN(writer, psize, ent.getValue());
}
Utils.closeFile(writer);
}
private void writeSection(ImgFileWriter writer, Section dataSection, Section indexSection,
List elementData)
{
Collections.sort(elementData);
SectionWriter subWriter = dataSection.makeSectionWriter(writer);
CharsetEncoder encoder = data.getEncoder();
for (TypElement elem : elementData)
elem.write(subWriter, encoder);
Utils.closeFile(subWriter);
int size = dataSection.getSize();
int typeSize = indexSection.getItemSize();
int psize = ptrSize(size);
indexSection.setItemSize((char) (typeSize + psize));
subWriter = indexSection.makeSectionWriter(writer);
for (TypElement elem : elementData) {
int offset = elem.getOffset();
int type = elem.getTypeForFile();
putN(subWriter, typeSize, type);
putN(subWriter, psize, offset);
}
Utils.closeFile(subWriter);
zapZero(dataSection, indexSection);
}
private void zapZero(Section... sect) {
for (Section s : sect) {
if (s.getSize() == 0) {
s.setPosition(0);
s.setItemSize((char) 0);
}
}
}
private int ptrSize(int size) {
int psize = 1;
if (size > 0xffffff)
psize = 4;
else if (size > 0xffff)
psize = 3;
else if (size > 0xff)
psize = 2;
return psize;
}
protected void putN(ImgFileWriter writer, int n, int value) {
switch (n) {
case 1:
writer.put((byte) value);
break;
case 2:
writer.putChar((char) value);
break;
case 3:
writer.put3(value);
break;
case 4:
writer.putInt(value);
break;
default: // Don't write anything.
assert false;
break;
}
}
public void setData(TypData data) {
this.data = data;
TypParam param = data.getParam();
header.setCodePage((char) param.getCodePage());
header.setFamilyId((char) param.getFamilyId());
header.setProductId((char) param.getProductId());
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypData.java 0000644 0000764 0000764 00000005153 12254147734 022653 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.srt.Sort;
/**
* Holds all the data for a typ file.
*
* @author Steve Ratcliffe
*/
public class TypData {
private final ShapeStacking stacking = new ShapeStacking();
private final TypParam param = new TypParam();
private final List polygons = new ArrayList();
private final List lines = new ArrayList();
private final List points = new ArrayList();
private final List icons = new ArrayList();
private Sort sort;
private CharsetEncoder encoder;
public void addPolygonStackOrder(int level, int type, int subtype) {
stacking.addPolygon(level, type, subtype);
}
public Sort getSort() {
return sort;
}
public void setSort(Sort sort) {
if (sort == null)
return;
if (this.sort != null) {
int origCodepage = this.sort.getCodepage();
if (origCodepage != 0) {
if (origCodepage != sort.getCodepage()) {
// This is just a warning, not a definite problem
System.out.println("WARNING: SortCode in TYP txt file different from" +
" command line setting");
}
}
}
this.sort = sort;
encoder = sort.getCharset().newEncoder();
param.setCodePage(sort.getCodepage());
}
public void setFamilyId(int val) {
param.setFamilyId(val);
}
public void setProductId(int val) {
param.setProductId(val);
}
public ShapeStacking getStacking() {
return stacking;
}
public TypParam getParam() {
return param;
}
public void addPolygon(TypPolygon polygon) {
polygons.add(polygon);
}
public CharsetEncoder getEncoder() {
return encoder;
}
public List getPolygons() {
return polygons;
}
public void addLine(TypLine line) {
lines.add(line);
}
public List getLines() {
return lines;
}
public void addPoint(TypPoint point) {
points.add(point);
}
public List getPoints() {
return points;
}
public void addIcon(TypIconSet current) {
icons.add(current);
}
public List getIcons() {
return icons;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/Rgb.java 0000644 0000764 0000764 00000003402 11665675646 022027 0 ustar steve steve package uk.me.parabola.imgfmt.app.typ;
import uk.me.parabola.imgfmt.FormatException;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
public class Rgb {
private final int b;
private final int g;
private final int r;
private final int a;
public Rgb(int r, int g, int b, int a) {
this.r = r;
this.g = g;
this.b = b;
this.a = a;
}
public Rgb(int r, int g, int b) {
this(r, g, b, 0xff);
}
/**
* Initialise from a string.
*
* The format is #RRGGBB and without the '#'. You can also append
* an alpha value. FF for fully opaque, and 00 for fully transparent.
* The typ file only deals with fully transparent.
*
* @param in The string form of the color.
*/
public Rgb(String in) {
String colour = in;
if (colour.startsWith("#"))
colour = colour.substring(1);
r = Integer.parseInt(colour.substring(0, 2), 16);
g = Integer.parseInt(colour.substring(2, 4), 16);
b = Integer.parseInt(colour.substring(4, 6), 16);
if (colour.length() > 6)
a = Integer.parseInt(colour.substring(6, 8), 16);
else
a = 0xff;
}
/**
* Create a new Rgb from the given one, adding the given alpha channel value.
*/
public Rgb(Rgb rgb, int alpha) {
this(rgb.r, rgb.g, rgb.b, alpha);
}
public void write(ImgFileWriter writer, byte type) {
if (type != 0x10)
throw new FormatException("Invalid color deep");
writer.put((byte) b);
writer.put((byte) g);
writer.put((byte) r);
}
public boolean isTransparent() {
return a == 0;
}
public String toString() {
if (a == 0xff)
return String.format("#%02x%02x%02x", r, g, b);
else
return String.format("#%02x%02x%02x%02x", r, g, b, a);
}
public int getB() {
return b;
}
public int getG() {
return g;
}
public int getR() {
return r;
}
public int getA() {
return a;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/Xpm.java 0000644 0000764 0000764 00000002105 11665675646 022060 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Holds everything read from an XPM value in the typ txt file.
*
* @author Steve Ratcliffe
*/
public class Xpm {
private ColourInfo colourInfo;
private Image image;
public ColourInfo getColourInfo() {
return colourInfo;
}
public void setColourInfo(ColourInfo colourInfo) {
this.colourInfo = colourInfo;
}
public void setImage(Image image) {
this.image = image;
}
public boolean hasImage() {
return image != null;
}
public void writeImage(ImgFileWriter writer) {
image.write(writer);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/AlphaAdder.java 0000644 0000764 0000764 00000002020 11711515370 023250 0 ustar steve steve /*
* Copyright (C) 2012.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
/**
* Interface for adding an alpha value to a previously saved colour value.
*
* The current TYP editors place the alpha value after the colour definition, eg:
*
* "#992299" alpha 5
*
* so we need to add the alpha value to a colour that has already been read
* in.
*
* @author Steve Ratcliffe
*/
public interface AlphaAdder {
/**
* Add an alpha value to the last colour that was saved.
*
* @param alpha A true alpha value ie 0 is transparent, 255 opaque.
*/
public void addAlpha(int alpha);
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/RgbWithTag.java 0000644 0000764 0000764 00000001610 11665675646 023316 0 ustar steve steve /*
* Copyright (C) 2008 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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 General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
/**
* @author Steve Ratcliffe
*/
public class RgbWithTag extends Rgb {
private final String tag;
public RgbWithTag(String tag, Rgb rgb) {
super(rgb.getR(), rgb.getG(), rgb.getB(), rgb.getA());
this.tag = tag;
}
public RgbWithTag(RgbWithTag rgb, int alpha) {
super(rgb, alpha);
this.tag = rgb.getTag();
}
public String getTag() {
return tag;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/package.html 0000644 0000764 0000764 00000000377 10735217321 022716 0 ustar steve steve The TYP file for custom rendering styles
This file contains definitions of how a map element will be rendered
on the GPS which allows you to display things in a different way.
Not all devices support the TYP file however.
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypIconSet.java 0000644 0000764 0000764 00000003705 11665675646 023364 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* The new multiple icon format.
* There can be several icons at different resolutions.
*
* @author Steve Ratcliffe
*/
public class TypIconSet extends TypElement {
private final List icons = new ArrayList();
public void write(ImgFileWriter writer, CharsetEncoder encoder) {
offset = writer.position();
// Start with the number of icons
writer.put((byte) icons.size());
for (Xpm xpm : icons) {
ColourInfo colourInfo = xpm.getColourInfo();
int nbits = calcBits(colourInfo);
writer.putChar((char) (nbits/2));
writer.put((byte) 1);
writer.put((byte) colourInfo.getWidth());
writer.put((byte) colourInfo.getHeight());
writeImage(writer, xpm);
}
}
private int calcBits(ColourInfo colourInfo) {
int bits = 0;
int bpp = colourInfo.getBitsPerPixel();
bits += colourInfo.getWidth() * colourInfo.getHeight() * bpp;
bits += colourInfo.getNumberOfSColoursForCM() * 3 * 8;
if (colourInfo.getNumberOfColours() == 0 && colourInfo.getColourMode() == 0x10)
bits += 3*8;
bits += 0x2c;
return bits;
}
public void addIcon(Xpm xpm) {
icons.add(xpm);
}
public String getLabel() {
if (labels.isEmpty())
return null;
return labels.get(0).getText();
}
/**
* Icon sets can have full colour pixmaps.
*/
public boolean simpleBitmap() {
return false;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/BitmapImage.java 0000644 0000764 0000764 00000003131 11665675646 023473 0 ustar steve steve package uk.me.parabola.imgfmt.app.typ;
import uk.me.parabola.imgfmt.app.BitWriter;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Holds a bitmap image for the typ file.
*
* There are a number of different formats allowed.
*
* Based on code by Thomas Lußnig, but type and colour information separated out and
* deals with more than just points.
*/
public class BitmapImage implements Image {
private final ColourInfo colourInfo;
private final String image;
public BitmapImage(ColourInfo colourInfo, String image) {
this.colourInfo = colourInfo;
this.image = image;
}
public void write(ImgFileWriter writer) {
final int bitSize = colourInfo.getBitsPerPixel();
int cpp = colourInfo.getCharsPerPixel();
int width = colourInfo.getWidth();
int height = colourInfo.getHeight();
int i = 0;
for (int h = 0; h < height; h++) {
// Each row is padded to a byte boundary, creating a new bit writer for every
// row ensures that happens.
BitWriter bitWriter = new BitWriter();
for (int w = 0; w < width; w++) {
String idx = image.substring(i, i + cpp);
i += cpp;
int val = colourInfo.getIndex(idx);
bitWriter.putn(val, bitSize);
}
writer.put(bitWriter.getBytes(), 0, bitWriter.getLength());
}
}
public int compare(BitmapImage a, BitmapImage b) {
throw new UnsupportedOperationException();
//if (a == null)
// return 1;
//if (b == null)
// return -1;
//if (a.typ < b.typ)
// return -1;
//if (a.typ > b.typ)
// return 1;
//if (a.dayNight < b.dayNight)
// return -1;
//if (a.dayNight > b.dayNight)
// return 1;
//return 0;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypParam.java 0000644 0000764 0000764 00000002052 11657205245 023033 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
/**
* General TYP file parameters.
*
* @author Steve Ratcliffe
*/
public class TypParam {
private int familyId;
private int productId;
private int codePage;
public int getFamilyId() {
return familyId;
}
public void setFamilyId(int familyId) {
this.familyId = familyId;
}
public int getProductId() {
return productId;
}
public void setProductId(int productId) {
this.productId = productId;
}
public int getCodePage() {
return codePage;
}
public void setCodePage(int codePage) {
this.codePage = codePage;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/Image.java 0000644 0000764 0000764 00000001266 11665675646 022345 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import uk.me.parabola.imgfmt.app.Writeable;
/**
* Interface for the different image types.
*
* @author Steve Ratcliffe
*/
public interface Image extends Writeable {
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/TypPolygon.java 0000644 0000764 0000764 00000003227 11677054151 023427 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import java.nio.charset.CharsetEncoder;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Holds the data for a polygon style.
*
* @author Steve Ratcliffe
*/
public class TypPolygon extends TypElement {
private static final int F_LABEL = 0x10;
private static final int F_EXTENDED = 0x20;
public void write(ImgFileWriter writer, CharsetEncoder encoder) {
offset = writer.position();
ColourInfo colourInfo = xpm.getColourInfo();
int scheme = colourInfo.getColourScheme();
if (!labels.isEmpty())
scheme |= F_LABEL;
if (fontStyle != 0 || dayFontColour != null)
scheme |= F_EXTENDED;
writer.put((byte) scheme);
colourInfo.write(writer);
if (xpm.hasImage())
xpm.writeImage(writer);
// The labels have a length byte to show the number of bytes following. There is
// also a flag in the length. The strings have a language number proceeding them.
// The strings themselves are null terminated.
if ((scheme & F_LABEL) != 0)
writeLabelBlock(writer, encoder);
// The extension section hold font style and colour information for the labels.
if ((scheme & F_EXTENDED) != 0) {
writeExtendedFontInfo(writer);
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/typ/ColourInfo.java 0000644 0000764 0000764 00000022152 11711515370 023352 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.typ;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import uk.me.parabola.imgfmt.app.BitWriter;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Writeable;
/**
* Holds colour information for elements in the typ file.
*
* The Colour information can relate to a bitmap or solid shapes.
*
* @author Steve Ratcliffe
*/
public class ColourInfo implements Writeable, AlphaAdder {
private static final int S_NIGHT = 1;
private static final int S_DAY_TRANSPARENT = 0x2;
private static final int S_NIGHT_TRANSPARENT = 0x4;
private static final int S_HAS_BITMAP = 0x8;
private int numberOfColours;
private int numberOfSolidColours;
private boolean hasBitmap;
private boolean hasBorder;
private final List colours = new ArrayList();
private final Map indexMap = new HashMap();
private char width;
private char height;
private char charsPerPixel;
private boolean simple = true;
private char colourMode;
/**
* Add a colour for this element.
* @param tag The xpm tag that represents the colour.
* @param rgb The actual colour.
*/
public void addColour(String tag, Rgb rgb) {
RgbWithTag cwt = new RgbWithTag(tag, rgb);
colours.add(cwt);
}
/**
* Add a transparent colour. Convenience routine.
*/
public void addTransparent(String colourTag) {
addColour(colourTag, new Rgb(0, 0, 0, 0));
}
public void setHasBitmap(boolean hasBitmap) {
this.hasBitmap = hasBitmap;
}
/**
* The colour scheme in use. This is a bitmask that has the following bits:
* 0 - Has night colour
* 1 - day background colour is transparent
* 2 - night background colour is transparent
* 3 - has bitmap
*
* If there is no night colour, then set the night background colour bit to be the same as
* the day one.
*
* @return The colour scheme bitmask. The term colour scheme is historical, it doesn't really
* describe it.
*/
public int getColourScheme() {
if (numberOfColours == 0)
numberOfColours = colours.size();
int scheme = 0;
if (hasBitmap)
scheme |= S_HAS_BITMAP;
if (numberOfColours == 4)
scheme |= S_NIGHT;
if (!hasBitmap && !hasBorder && numberOfColours == 2)
scheme |= S_NIGHT | S_DAY_TRANSPARENT | S_NIGHT_TRANSPARENT;
if (numberOfColours < 2 || colours.get(1).isTransparent())
scheme |= S_DAY_TRANSPARENT;
if (numberOfColours == 4 && (colours.get(3).isTransparent()))
scheme |= S_NIGHT_TRANSPARENT;
if ((scheme & S_NIGHT) == 0)
if ((scheme & S_DAY_TRANSPARENT) != 0)
scheme |= S_NIGHT_TRANSPARENT;
return scheme;
}
/**
* Get the number of bits per pixel that will be used in the written bitmap.
*
* This depends on the colour mode and number of colours to be represented.
*/
public int getBitsPerPixel() {
if (simple)
return 1;
// number of colours includes the transparent pixel in colormode=0x10 so this
// works for all colour modes.
int nc = numberOfColours;
if (nc == 0)
return 24;
else if (nc < 2)
return 1;
else if (nc < 4)
return 2;
else if (nc < 16)
return 4;
else
return 8;
}
/**
* Write out the colours only.
*/
public void write(ImgFileWriter writer) {
if (colourMode == 0x20) {
writeColours20(writer);
} else {
for (Rgb rgb : colours) {
if (!rgb.isTransparent())
rgb.write(writer, (byte) 0x10);
}
}
}
/**
* Write out the colours in the colormode=x20 case.
*/
private void writeColours20(ImgFileWriter writer) {
BitWriter bw = new BitWriter();
for (Rgb rgb : colours) {
bw.putn(rgb.getB(), 8);
bw.putn(rgb.getG(), 8);
bw.putn(rgb.getR(), 8);
int alpha = 0xff - rgb.getA();
alpha = alphaRound4(alpha);
bw.putn(alpha, 4);
}
writer.put(bw.getBytes(), 0, bw.getLength());
}
/**
* Round alpha value to four bits.
* @param alpha The original alpha value eg 0xf0.
* @return Rounded alpha to four bits eg 0xe.
*/
static int alphaRound4(int alpha) {
int top = (alpha >> 4) & 0xf;
int low = alpha & 0xf;
int diff = low-top;
if (diff > 8)
top++;
else if (diff < -8)
top--;
return top;
}
public int getIndex(String tag) {
Integer ind = indexMap.get(tag);
// If this is a simple bitmap (for line or polygon), then the foreground colour is
// first and so has index 0, but we want the foreground to have index 1, so reverse.
if (simple)
ind = ~ind;
return ind;
}
public void setWidth(int width) {
this.width = (char) width;
}
public void setHeight(int height) {
this.height = (char) height;
}
public void setNumberOfColours(int numberOfColours) {
this.numberOfColours = numberOfColours;
}
public void setCharsPerPixel(int charsPerPixel) {
this.charsPerPixel = (char) (charsPerPixel == 0 ? 1 : charsPerPixel);
}
public int getNumberOfColours() {
return numberOfColours;
}
public int getNumberOfSColoursForCM() {
if (colourMode == 0x10)
return numberOfSolidColours;
else
return numberOfColours;
}
public int getCharsPerPixel() {
return charsPerPixel;
}
public int getHeight() {
return height;
}
public int getWidth() {
return width;
}
public int getColourMode() {
return colourMode;
}
public void setColourMode(int colourMode) {
this.colourMode = (char) colourMode;
}
public void setSimple(boolean simple) {
this.simple = simple;
}
public void setHasBorder(boolean hasBorder) {
this.hasBorder = hasBorder;
}
/**
* Replace the last pixel with a pixel with the same colour components and the given
* alpha.
*
* This is used when the alpha value is specified separately to the colour values in the
* input file.
* @param alpha The alpha value to be added to the pixel. This is a real alpha, not a transparency.
*/
public void addAlpha(int alpha) {
int last = colours.size();
RgbWithTag rgb = colours.get(last - 1);
rgb = new RgbWithTag(rgb, alpha);
colours.set(last - 1, rgb);
}
/**
* Analyse the colour pallet and normalise it.
*
* Try to work out what is required from the supplied colour pallet and set the colour mode
* and rearrange transparent pixels if necessary to be in the proper place.
*
* At the end we build the index from colour tag to pixel index.
*
* @param simple If this is a line or polygon.
* @return A string describing the validation failure.
*/
public String analyseColours(boolean simple) {
setSimple(simple);
if (simple) {
// There can be up to four colours, no partial transparency, and a max of one transparent pixel
// in each of the day/night sections.
if (numberOfColours > 4)
return ("Too many colours for a line or polygon");
if (numberOfColours == 0)
return "Line or polygon cannot have zero colours";
// Putting the transparent pixel first is common, so reverse if found
if (colours.get(0).isTransparent()) {
if (numberOfColours < 2)
return "Only colour cannot be transparent for line or polygon";
swapColour(0, 1);
}
if (numberOfColours > 2 && colours.get(2).isTransparent()) {
if (numberOfColours < 4)
return "Only colour cannot be transparent for line or polygon";
swapColour(2, 3);
}
// There can only be one transparent pixel per colour pair
if (numberOfColours > 1 && colours.get(0).isTransparent())
return "Both day foreground and background are transparent";
if (numberOfColours > 3 && colours.get(2).isTransparent())
return "Both night foreground and background are transparent";
} else {
int transIndex = 0; // index of last transparent pixel, only used when there is only one
int nTrans = 0; // completely transparent
int nAlpha = 0; // partially transparent
int count = 0; // total number of colours
for (RgbWithTag rgb : colours) {
if (rgb.isTransparent()) {
nTrans++;
transIndex = count;
}
if (rgb.getA() != 0xff && rgb.getA() != 0)
nAlpha++;
count++;
}
if (nAlpha > 0 || (count > 0 && count == nTrans)) {
// If there is any partial transparency we need colour mode 0x20
// Also if there is only one pixel and it is transparent, since otherwise there would be zero
// solid colours and that is a special case used to indicate a true colour pixmap.
colourMode = 0x20;
} else if (nTrans == 1) {
colourMode = 0x10;
// Ensure the transparent pixel is at the end
RgbWithTag rgb = colours.remove(transIndex);
colours.add(rgb);
}
}
int count = 0;
for (RgbWithTag rgb : colours) {
indexMap.put(rgb.getTag(), count++);
if (!rgb.isTransparent())
numberOfSolidColours++;
}
return null;
}
private void swapColour(int c1, int c2) {
RgbWithTag tmp = colours.get(c1);
colours.set(c1, colours.get(c2));
colours.set(c2, tmp);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/ImgFile.java 0000644 0000764 0000764 00000004400 11400726372 021770 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 03-Dec-2006
*/
package uk.me.parabola.imgfmt.app;
import java.io.Closeable;
import java.io.IOException;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.log.Logger;
/**
* Base class for all the img files. There is a common header that
* all the sub-files share. They also have means of reading and writing
* themselves.
*
* @author Steve Ratcliffe
*/
public abstract class ImgFile implements Closeable {
private static final Logger log = Logger.getLogger(ImgFile.class);
private CommonHeader header;
private ImgFileWriter writer;
private ImgFileReader reader;
private boolean readable;
private boolean writable;
public void close() {
try {
sync();
} catch (IOException e) {
log.debug("could not sync file");
}
Utils.closeFile(writer);
Utils.closeFile(reader);
}
public int position() {
if (readable)
return (int) reader.position();
else
return writer.position();
}
protected CommonHeader getHeader() {
return header;
}
public long getSize() {
if (writable)
return writer.getSize();
throw new UnsupportedOperationException("getSize not implemented for read");
}
protected void position(long pos) {
writer.position(pos);
}
protected final void sync() throws IOException {
if (!writable)
return;
getWriter().sync();
}
protected ImgFileWriter getWriter() {
return writer;
}
protected void setWriter(ImgFileWriter writer) {
writable = true;
this.writer = writer;
}
protected ImgFileReader getReader() {
return reader;
}
protected void setReader(ImgFileReader reader) {
readable = true;
this.reader = reader;
}
protected final void setHeader(CommonHeader header) {
this.header = header;
}
protected boolean isWritable() {
return writable;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/Exit.java 0000644 0000764 0000764 00000003115 11400726372 021367 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Jan 1, 2008
*/
package uk.me.parabola.imgfmt.app;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.lbl.ExitFacility;
import uk.me.parabola.imgfmt.app.lbl.Highway;
/**
* Represent a motorway exit
*
* @author Mark Burton
*/
public class Exit {
public final static String TAG_ROAD_REF = "exit:road_ref";
public final static String TAG_TO = "exit:to";
public final static String TAG_FACILITY = "exit:facility";
private final Highway highway;
private Label description;
private final List facilities = new ArrayList();
public Exit(Highway highway) {
this.highway = highway;
}
public void setDescription(Label description) {
this.description = description;
}
public void addFacility(ExitFacility facility) {
facilities.add(facility);
}
public boolean getOvernightParking() {
return false; // FIXME
}
public Highway getHighway() {
return highway;
}
public List getFacilities() {
return facilities;
}
public Label getDescription() {
return description;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/Section.java 0000644 0000764 0000764 00000007117 11657205245 022075 0 ustar steve steve /*
* Copyright (C) 2007 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: Dec 15, 2007
*/
package uk.me.parabola.imgfmt.app;
import java.io.IOException;
/**
* Represents an item size the position where those items start and the
* total size of the section.
*/
public class Section {
private char itemSize;
private int size;
private int position;
private Section link;
private int extraValue;
public Section() {
}
public Section(char itemSize) {
this.itemSize = itemSize;
}
public Section(Section link, char itemSize) {
this.itemSize = itemSize;
this.link = link;
}
public Section(Section link) {
this.link = link;
}
public void inc() {
size += itemSize;
}
public char getItemSize() {
return itemSize;
}
public void setItemSize(char itemSize) {
this.itemSize = itemSize;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
/**
* Get the start position of this section. If this is linked to another
* section, then we return the end address of that section.
* @return The first offset for this section.
*/
public int getPosition() {
if (link != null)
return link.getEndPos();
return position;
}
public void setPosition(int position) {
this.position = position;
// Setting a position breaks the link
this.link = null;
}
/**
* Get the position of the end of the section.
* @return The offset of the end of the section relative to the beginning
* of the application file.
*/
public int getEndPos() {
return getPosition() + size;
}
public String toString() {
return "pos=" + getPosition() + ", size=" + size + ", itemSize=" + itemSize;
}
/**
* Get the number of items in the section. This should only be called
* if the itemSize is set.
* @return The number of items in the section, or zero if this is not
* a fixed size item kind of section.
*/
public int getNumItems() {
if (itemSize == 0)
return 0;
return size/ (int) itemSize;
}
protected int getExtraValue() {
return extraValue;
}
public void setExtraValue(int extraValue) {
this.extraValue = extraValue;
}
public void readSectionInfo(ImgFileReader reader, boolean withItemSize) {
setPosition(reader.getInt());
setSize(reader.getInt());
if (withItemSize)
setItemSize(reader.getChar());
}
public SectionWriter makeSectionWriter(ImgFileWriter writer) {
setPosition(writer.position());
return new SectionWriter(writer, this);
}
public void writeSectionInfo(ImgFileWriter writer) {
writeSectionInfo(writer, false);
}
public void writeSectionInfo(ImgFileWriter writer, boolean withItemSize) {
writeSectionInfo(writer, withItemSize, false);
}
public void writeSectionInfo(ImgFileWriter writer, boolean withItemSize, boolean withExtraValue) {
writer.putInt(getPosition());
writer.putInt(getSize());
if (withItemSize || getItemSize() > 0)
writer.putChar(getItemSize());
if (withExtraValue)
writer.putInt(getExtraValue());
}
public static void close(ImgFileWriter writer) {
assert writer instanceof SectionWriter;
try {
writer.close();
} catch (IOException e) {
// ignore as this is only for section writers.
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/BufferedImgFileWriter.java 0000644 0000764 0000764 00000012151 12333071201 024620 0 ustar steve steve /*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* 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 General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 07-Dec-2006
*/
package uk.me.parabola.imgfmt.app;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import uk.me.parabola.imgfmt.MapFailedException;
import uk.me.parabola.imgfmt.fs.ImgChannel;
import uk.me.parabola.log.Logger;
/**
* A straight forward implementation that just keeps all the data in a buffer
* until the file needs to be written to disk.
*
* @author Steve Ratcliffe
*/
public class BufferedImgFileWriter implements ImgFileWriter {
private static final Logger log = Logger.getLogger(BufferedImgFileWriter.class);
private static final int KBYTE = 1024;
private static final int INIT_SIZE = 16 * KBYTE;
private static final int GROW_SIZE = 128 * KBYTE;
private static final int GUARD_SIZE = KBYTE;
private final ImgChannel chan;
private ByteBuffer buf = ByteBuffer.allocate(INIT_SIZE);
private int bufferSize = INIT_SIZE;
// The size of the file. Note that for this to be set properly, the
// position must be set to a low value after the full file is written. This
// always happens because we go back and write the header after all is
// written.
private int maxSize;
// The maximum allowed file size.
private long maxAllowedSize = 0xffffff;
public BufferedImgFileWriter(ImgChannel chan) {
this.chan = chan;
buf.order(ByteOrder.LITTLE_ENDIAN);
}
/**
* Called to write out any saved buffers. The strategy may write
* directly to the file in which case this would have nothing or
* little to do.
*/
public void sync() throws IOException {
buf.limit(maxSize);
buf.position(0);
log.debug("syncing to pos", chan.position(), ", size", buf.limit());
chan.write(buf);
}
/**
* Get the position. Needed because may not be reflected in the underlying
* file if being buffered.
*
* @return The logical position within the file.
*/
public int position() {
return buf.position();
}
/**
* Set the position of the file.
*
* @param pos The new position in the file.
*/
public void position(long pos) {
int cur = position();
if (cur > maxSize)
maxSize = cur;
buf.position((int) pos);
}
/**
* Called when the stream is closed. Any resources can be freed.
*/
public void close() throws IOException {
chan.close();
}
/**
* Write out a single byte.
*
* @param b The byte to write.
*/
public void put(byte b) {
ensureSize(1);
buf.put(b);
}
/**
* Write out two bytes. Done in the correct byte order.
*
* @param c The value to write.
*/
public void putChar(char c) {
ensureSize(2);
buf.putChar(c);
}
/**
* Write out a 3 byte value in the correct byte order etc.
*
* @param val The value to write.
*/
public void put3(int val) {
ensureSize(3);
buf.put((byte) (val & 0xff));
buf.putChar((char) (val >> 8));
}
/**
* Write out 4 byte value.
*
* @param val The value to write.
*/
public void putInt(int val) {
ensureSize(4);
buf.putInt(val);
}
/**
* Write out an arbitrary length sequence of bytes.
*
* @param val The values to write.
*/
public void put(byte[] val) {
ensureSize(val.length);
buf.put(val);
}
/**
* Write out part of a byte array.
*
* @param src The array to take bytes from.
* @param start The start position.
* @param length The number of bytes to write.
*/
public void put(byte[] src, int start, int length) {
ensureSize(length);
buf.put(src, start, length);
}
public void put(ByteBuffer src) {
ensureSize(src.limit());
buf.put(src);
}
/**
* Get the size of the file as written.
*
* NOTE: that calling this is only valid at certain times.
*
* @return The size of the file, if it is available.
*/
public long getSize() {
return maxSize;
}
public ByteBuffer getBuffer() {
return buf;
}
/**
* Make sure there is enough room for the data we are about to write.
*
* @param length The amount of data.
*/
private void ensureSize(int length) {
int needed = buf.position() + length;
if (needed > (bufferSize - GUARD_SIZE)) {
while(needed > (bufferSize - GUARD_SIZE))
bufferSize += GROW_SIZE;
if (bufferSize > maxAllowedSize) {
// Previous message was confusing people, although it is difficult to come
// up with something that is strictly true in all situations.
throw new MapFailedException(
"There is not enough room in a single garmin map for all the input data." +
" The .osm file should be split into smaller pieces first.");
}
ByteBuffer newb = ByteBuffer.allocate(bufferSize);
newb.order(ByteOrder.LITTLE_ENDIAN);
buf.flip();
newb.put(buf);
buf = newb;
}
}
public void setMaxSize(long maxSize) {
this.maxAllowedSize = maxSize;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/ 0000755 0000764 0000764 00000000000 12651103763 020425 5 ustar steve steve mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/SRTFile.java 0000644 0000764 0000764 00000011343 12346663602 022546 0 ustar steve steve /*
* Copyright (C) 2010.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.BufferedImgFileWriter;
import uk.me.parabola.imgfmt.app.ImgFile;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.SectionWriter;
import uk.me.parabola.imgfmt.fs.ImgChannel;
/**
* The SRT file. This contains a table showing the sort order of
* the characters that is being used.
*
* @author Steve Ratcliffe
*/
public class SRTFile extends ImgFile {
private final SRTHeader header;
private Sort sort;
private boolean isMulti;
private String description;
private final List srt8Starts = new ArrayList<>();
public SRTFile(ImgChannel chan) {
header = new SRTHeader();
setHeader(header);
BufferedImgFileWriter fileWriter = new BufferedImgFileWriter(chan);
fileWriter.setMaxSize(Long.MAX_VALUE);
setWriter(fileWriter);
// Position at the start of the writable area.
position(header.getHeaderLength());
}
/**
* Write out the file.
* This file has an unusual layout. There are several header like structures within
* the main body of the file, with the real header being very small.
*/
public void write() {
ImgFileWriter writer = getWriter();
writeDescription(writer);
SectionWriter subWriter = header.makeSectionWriter(writer);
subWriter.position(sort.isMulti()? SRTHeader.HEADER3_MULTI_LEN: SRTHeader.HEADER3_LEN);
writeSrt4Chars(subWriter);
writeSrt5Expansions(subWriter);
if (sort.isMulti()) {
for (int i = 0; i <= sort.getMaxPage(); i++)
srt8Starts.add(-1);
writeSrt8(subWriter);
writeSrt7(subWriter);
}
subWriter.close();
// Header 2 is just after the real header
writer.position(header.getHeaderLength());
header.writeHeader2(writer);
// Header 3 is after the description
writer.position(header.getHeaderLength() + description.length() + 1 + SRTHeader.HEADER2_LEN);
header.writeHeader3(writer);
header.writeHeader(writer);
}
private void writeDescription(ImgFileWriter writer) {
writer.position(header.getHeaderLength() + SRTHeader.HEADER2_LEN);
writer.put(description.getBytes(Charset.forName("ascii")));
writer.put((byte) 0);
header.endDescription(writer.position());
}
/**
* Write SRT4 the character table.
*
* @param writer The img file writer.
*/
private void writeSrt4Chars(ImgFileWriter writer) {
for (int i = 1; i < 256; i++) {
writer.put(sort.getFlags(i));
writeWeights(writer, i);
}
header.endCharTable(writer.position());
}
private void writeWeights(ImgFileWriter writer, int i) {
if (isMulti) {
writer.putChar((char) sort.getPrimary(i));
writer.put((byte) sort.getSecondary(i));
writer.put((byte) sort.getTertiary(i));
} else {
writer.put((byte) sort.getPrimary(i));
writer.put((byte) ((sort.getTertiary(i) << 4) | (sort.getSecondary(i) & 0xf)));
}
}
/**
* Write SRT5, the expansion table.
*
* Write out the expansion table. This is referenced from the character table, when
* the top nibble of the type is set via the primary position value.
*/
private void writeSrt5Expansions(ImgFileWriter writer) {
int size = sort.getExpansionSize();
for (int j = 1; j <= size; j++) {
CodePosition b = sort.getExpansion(j);
if (isMulti) {
writer.putChar(b.getPrimary());
writer.put(b.getSecondary());
writer.put(b.getTertiary());
} else {
writer.put((byte) b.getPrimary());
writer.put((byte) ((b.getTertiary() << 4) | (b.getSecondary() & 0xf)));
}
}
header.endTab2(writer.position());
}
private void writeSrt7(SectionWriter writer) {
assert sort.isMulti();
for (int i = 1; i <= sort.getMaxPage(); i++) {
writer.putInt(srt8Starts.get(i));
}
header.endSrt7(writer.position());
}
private void writeSrt8(SectionWriter writer) {
assert sort.isMulti();
int offset = 0;
for (int p = 1; p <= sort.getMaxPage(); p++) {
if (sort.hasPage(p)) {
srt8Starts.set(p, offset);
for (int j = 0; j < 256; j++) {
int ch = p * 256 + j;
writer.put(sort.getFlags(ch));
writeWeights(writer, ch);
offset += 5;
}
}
}
header.endSrt8(writer.position());
}
public void setSort(Sort sort) {
this.sort = sort;
header.setSort(sort);
description = sort.getDescription();
isMulti = sort.isMulti();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/Sort.java 0000644 0000764 0000764 00000053127 12354242000 022213 0 ustar steve steve /*
* Copyright (C) 2010, 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CodingErrorAction;
import java.text.CollationKey;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import uk.me.parabola.imgfmt.ExitException;
import uk.me.parabola.imgfmt.app.Label;
/**
* Represents the sorting positions for all the characters in a codepage.
*
* A map contains a file that determines how the characters are to be sorted. So we
* have to have to be able to create such a file and sort with exactly the same rules
* as is contained in it.
*
* What about the java {@link java.text.RuleBasedCollator}? It turns out that it is possible to
* make it work in the way we need it to, although it doesn't help with creating the srt file.
* Also it is significantly slower than this implementation, so this one is staying. I also
* found that sorting with the sort keys and the collator gave different results in some
* cases. This implementation does not.
*
* Be careful when benchmarking. With small lists (< 10000 entries) repeated runs cause some
* pretty aggressive optimisation to kick in. This tends to favour this implementation which has
* much tighter loops that the java7 or ICU implementations, but this may not be realised with
* real workloads.
*
* @author Steve Ratcliffe
*/
public class Sort {
private static final byte[] ZERO_KEY = new byte[4];
private static final Integer NO_ORDER = 0;
private int codepage;
private int id1; // Unknown - identifies the sort
private int id2; // Unknown - identifies the sort
private String description;
private Charset charset;
private final Page[] pages = new Page[256];
private final List expansions = new ArrayList<>();
private int maxExpSize = 1;
private CharsetEncoder encoder;
private boolean multi;
private int maxPage;
public Sort() {
pages[0] = new Page();
}
public void add(int ch, int primary, int secondary, int tertiary, int flags) {
ensurePage(ch >>> 8);
if (getPrimary(ch) != 0)
throw new ExitException(String.format("Repeated primary index 0x%x", ch & 0xff));
setPrimary (ch, primary);
setSecondary(ch, secondary);
setTertiary( ch, tertiary);
setFlags(ch, flags);
}
/**
* Run after all sorting order points have been added.
*
* Make sure that all tertiary values of secondary ignorable are greater
* than any normal tertiary value.
*
* And the same for secondaries on primary ignorable.
*/
public void finish() {
int maxSecondary = 0;
int maxTertiary = 0;
for (Page p : pages) {
if (p == null)
continue;
for (int i = 0; i < 256; i++) {
if (((p.flags[i] >>> 4) & 0x3) == 0) {
if (p.getPrimary(i) != 0) {
byte second = p.getSecondary(i);
maxSecondary = Math.max(maxSecondary, second);
if (second != 0) {
maxTertiary = Math.max(maxTertiary, p.getTertiary(i));
}
}
}
}
}
for (Page p : pages) {
if (p == null)
continue;
for (int i = 0; i < 256; i++) {
if (((p.flags[i] >>> 4) & 0x3) != 0) continue;
if (p.getPrimary(i) == 0) {
if (p.getSecondary(i) == 0) {
if (p.getTertiary(i) != 0) {
p.setTertiary(i, p.getTertiary(i) + maxTertiary);
}
} else {
p.setSecondary(i, p.getSecondary(i) + maxSecondary);
}
}
}
}
}
/**
* Return a table indexed by a character value in the target codepage, that gives the complete sort
* position of the character.
*
* This is only used for testing.
*
* @return A table of sort positions.
*/
public char[] getSortPositions() {
char[] tab = new char[256];
for (int i = 1; i < 256; i++) {
tab[i] = (char) (((getPrimary(i) << 8) & 0xff00) | ((getSecondary(i) << 4) & 0xf0) | (getTertiary(i) & 0xf));
}
return tab;
}
/**
* Create a sort key for a given unicode string. The sort key can be compared instead of the original strings
* and will compare based on the sorting represented by this Sort class.
*
* Using a sort key is more efficient if many comparisons are being done (for example if you are sorting a
* list of strings).
*
* @param object This is saved in the sort key for later retrieval and plays no part in the sorting.
* @param s The string for which the sort key is to be created.
* @param second Secondary sort key.
* @param cache A cache for the created keys. This is for saving memory so it is essential that this
* is managed by the caller.
* @return A sort key.
*/
public SortKey createSortKey(T object, String s, int second, Map cache) {
// If there is a cache then look up and return the key.
// This is primarily for memory management, not for speed.
byte[] key;
if (cache != null) {
key = cache.get(s);
if (key != null)
return new SrtSortKey<>(object, key, second);
}
try {
char[] chars;
if (isMulti()) {
chars = s.toCharArray();
} else {
ByteBuffer out = encoder.encode(CharBuffer.wrap(s));
byte[] bval = out.array();
chars = new char[bval.length];
for (int i = 0; i < bval.length; i++)
chars[i] = (char) (bval[i] & 0xff);
}
// In theory you could have a string where every character expands into maxExpSize separate characters
// in the key. However if we allocate enough space to deal with the worst case, then we waste a
// vast amount of memory. So allocate a minimal amount of space, try it and if it fails reallocate the
// maximum amount.
//
// We need +1 for the null bytes, we also +2 for a couple of expanded characters. For a complete
// german map this was always enough in tests.
key = new byte[(chars.length + 1 + 2) * 4];
try {
fillCompleteKey(chars, key);
} catch (ArrayIndexOutOfBoundsException e) {
// Ok try again with the max possible key size allocated.
key = new byte[(chars.length+1) * 4 * maxExpSize];
fillCompleteKey(chars, key);
}
if (cache != null)
cache.put(s, key);
return new SrtSortKey<>(object, key, second);
} catch (CharacterCodingException e) {
return new SrtSortKey<>(object, ZERO_KEY);
}
}
/**
* Create a sort key based on a Label.
*
* The label will contain the actual characters (after transliteration for example)
* @param object This is saved in the sort key for later retrieval and plays no part in the sorting.
* @param label The label, the actual written bytes/chars will be used as input to the sort.
* @param second Secondary sort key.
* @param cache A cache for the created keys. This is for saving memory so it is essential that this
* is managed by the caller.
* @return A sort key.
*/
public SortKey createSortKey(T object, Label label, int second, Map cache) {
byte[] key;
if (cache != null) {
key = cache.get(label);
if (key != null)
return new SrtSortKey<>(object, key, second);
}
char[] encText = label.getEncText();
// In theory you could have a string where every character expands into maxExpSize separate characters
// in the key. However if we allocate enough space to deal with the worst case, then we waste a
// vast amount of memory. So allocate a minimal amount of space, try it and if it fails reallocate the
// maximum amount.
//
// We need +1 for the null bytes, we also +2 for a couple of expanded characters. For a complete
// german map this was always enough in tests.
key = new byte[(encText.length + 1 + 2) * 4];
try {
fillCompleteKey(encText, key);
} catch (ArrayIndexOutOfBoundsException e) {
// Ok try again with the max possible key size allocated.
key = new byte[encText.length * 4 * maxExpSize + 4];
fillCompleteKey(encText, key);
}
if (cache != null)
cache.put(label, key);
return new SrtSortKey<>(object, key, second);
}
/**
* Convenient version of create sort key method.
* @see #createSortKey(Object, String, int, Map)
*/
public SortKey createSortKey(T object, String s, int second) {
return createSortKey(object, s, second, null);
}
/**
* Convenient version of create sort key method.
*
* @see #createSortKey(Object, String, int, Map)
*/
public SortKey createSortKey(T object, String s) {
return createSortKey(object, s, 0, null);
}
public SortKey createSortKey(T object, Label label) {
return createSortKey(object, label, 0, null);
}
public SortKey createSortKey(T object, Label label, int second) {
return createSortKey(object, label, second, null);
}
/**
* Fill in the key from the given byte string.
*
* @param bVal The string for which we are creating the sort key.
* @param key The sort key. This will be filled in.
*/
private void fillCompleteKey(char[] bVal, byte[] key) {
int start = fillKey(Collator.PRIMARY, bVal, key, 0);
start = fillKey(Collator.SECONDARY, bVal, key, start);
fillKey(Collator.TERTIARY, bVal, key, start);
}
/**
* Fill in the output key for a given strength.
*
* @param input The input string in a particular 8 bit codepage.
* @param outKey The output sort key.
* @param start The index into the output key to start at.
* @return The next position in the output key.
*/
private int fillKey(int type, char[] input, byte[] outKey, int start) {
int index = start;
for (char c : input) {
if (!hasPage(c >>> 8))
continue;
int exp = (getFlags(c) >> 4) & 0x3;
if (exp == 0) {
index = writePos(type, c, outKey, index);
} else {
// now have to redirect to a list of input chars, get the list via the primary value always.
int idx = getPrimary(c);
for (int i = idx - 1; i < idx + exp; i++) {
int pos = expansions.get(i).getPosition(type);
if (pos != 0) {
if (type == Collator.PRIMARY)
outKey[index++] = (byte) ((pos >>> 8) & 0xff);
outKey[index++] = (byte) pos;
}
}
}
}
if (type == Collator.PRIMARY)
outKey[index++] = '\0';
outKey[index++] = '\0';
return index;
}
public int getPrimary(int ch) {
return this.pages[ch >>> 8].getPrimary(ch);
}
public int getSecondary(int ch) {
return this.pages[ch >>> 8].getSecondary(ch);
}
public int getTertiary(int ch) {
return this.pages[ch >>> 8].getTertiary(ch);
}
public byte getFlags(int ch) {
assert ch >= 0;
return this.pages[ch >>> 8].flags[ch & 0xff];
}
public int getCodepage() {
return codepage;
}
public Charset getCharset() {
return charset;
}
public int getId1() {
return id1;
}
public void setId1(int id1) {
this.id1 = id1;
}
public int getId2() {
return id2;
}
public void setId2(int id2) {
this.id2 = id2 & 0x7fff;
}
/**
* Get the sort order as a single integer.
* A combination of id1 and id2. I think that they are arbitrary so may as well treat them as one.
*
* @return id1 and id2 as if they were a little endian 2 byte integer.
*/
public int getSortOrderId() {
return (this.id2 << 16) + (this.id1 & 0xffff);
}
/**
* Set the sort order as a single integer.
* @param id The sort order id.
*/
public void setSortOrderId(int id) {
id1 = id & 0xffff;
id2 = (id >>> 16) & 0x7fff;
}
public void setCodepage(int codepage) {
this.codepage = codepage;
charset = charsetFromCodepage(codepage);
encoder = charset.newEncoder();
encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
/**
* Add an expansion to the sort.
* An expansion is a letter that sorts as if it were two separate letters.
*
* The case were two letters sort as if the were just one (and more complex cases) are
* not supported or are unknown to us.
*
* @param ch The code point of this letter in the code page.
* @param inFlags The initial flags, eg if it is a letter or not.
* @param expansionList The letters that this letter sorts as, as code points in the codepage.
*/
public void addExpansion(int ch, int inFlags, List expansionList) {
ensurePage(ch >>> 8);
setFlags(ch, (byte) ((inFlags & 0xf) | (((expansionList.size()-1) << 4) & 0xf0)));
// Check for repeated definitions
if (getPrimary(ch) != 0)
throw new ExitException(String.format("repeated code point %x", ch));
setPrimary(ch, (expansions.size() + 1));
setSecondary(ch, 0);
setTertiary(ch, 0);
maxExpSize = Math.max(maxExpSize, expansionList.size());
for (Integer b : expansionList) {
CodePosition cp = new CodePosition();
cp.setPrimary((char) getPrimary(b & 0xff));
// Currently sort without secondary or tertiary differences to the base letters.
cp.setSecondary((byte) getSecondary(b & 0xff));
cp.setTertiary((byte) getTertiary(b & 0xff));
expansions.add(cp);
}
}
/**
* Get the expansion with the given index, one based.
* @param val The one-based index number of the extension.
*/
public CodePosition getExpansion(int val) {
return expansions.get(val - 1);
}
public Collator getCollator() {
return new SrtCollator(codepage);
}
public int getExpansionSize() {
return expansions.size();
}
public String toString() {
return String.format("sort cp=%d order=%08x", codepage, getSortOrderId());
}
private void setPrimary(int ch, int val) {
this.pages[ch >>> 8].setPrimary(ch, val);
}
private void setSecondary(int ch, int val) {
this.pages[ch >>> 8].setSecondary(ch, val);
}
private void setTertiary(int ch, int val) {
this.pages[ch >>> 8].setTertiary(ch, val);
}
private void setFlags(int ch, int val) {
this.pages[ch >>> 8].flags[ch & 0xff] = (byte) val;
}
public static Charset charsetFromCodepage(int codepage) {
Charset charset;
switch (codepage) {
case 0:
charset = Charset.forName("ascii");
break;
case 65001:
charset = Charset.forName("UTF-8");
break;
case 932:
// Java uses "ms932" for code page 932
// (Windows-31J, Shift-JIS + MS extensions)
charset = Charset.forName("ms932");
break;
default:
charset = Charset.forName("cp" + codepage);
break;
}
return charset;
}
public void setMulti(boolean multi) {
this.multi = multi;
}
public boolean isMulti() {
return multi;
}
public int getPos(int type, int ch) {
return pages[ch >>> 8].getPos(type, ch);
}
public int writePos(int type, int ch, byte[] outkey, int start) {
return pages[ch >>> 8].writePos(type, ch, outkey, start);
}
/**
* Ensure that the given page exists in the page array.
*
* @param n The page index.
*/
private void ensurePage(int n) {
assert n == 0 || isMulti();
if (this.pages[n] == null) {
this.pages[n] = new Page();
if (n > maxPage)
maxPage = n;
}
}
/**
* The max page, top 8+ bits of the character that we have information on.
*/
public int getMaxPage() {
return maxPage;
}
/**
* @return True if there is at least one character with the given page/block number.
*/
public boolean hasPage(int p) {
return pages[p] != null;
}
/**
* Holds the sort positions of a 256 character block.
*/
private static class Page {
private final char[] primary = new char[256];
private final byte[] secondary = new byte[256];
private final byte[] tertiary = new byte[256];
private final byte[] flags = new byte[256];
char getPrimary(int ch) {
return primary[ch & 0xff];
}
void setPrimary(int ch, int val) {
primary[ch & 0xff] = (char) val;
}
byte getSecondary(int ch) {
return secondary[ch & 0xff];
}
void setSecondary(int ch, int val) {
secondary[ch & 0xff] = (byte) val;
}
byte getTertiary(int ch) {
return tertiary[ch & 0xff];
}
void setTertiary(int ch, int val) {
tertiary[ch & 0xff] = (byte) val;
}
/**
* Get the sort position data for a given strength for a character.
* @param type The collation strength PRIMARY, SECONDARY etc.
* @param ch The character.
* @return The sorting weight for the given character.
*/
public int getPos(int type, int ch) {
switch (type) {
case Collator.PRIMARY:
return getPrimary(ch) & 0xffff;
case Collator.SECONDARY:
return getSecondary(ch) & 0xff;
case Collator.TERTIARY:
return getTertiary(ch) & 0xff;
default:
assert false : "bad collation type passed";
return 0;
}
}
/**
* Write a sort position for a given character to a sort key.
* @param strength The sort strength type.
* @param ch The character.
* @param outKey The output key.
* @param start The offset into outKey, the new position is written here.
* @return The new start offset, after the key information has been written.
*/
public int writePos(int strength, int ch, byte[] outKey, int start) {
int pos = getPos(strength, ch);
if (pos != 0) {
if (strength == Collator.PRIMARY)
outKey[start++] = (byte) ((pos >> 8) & 0xff); // for 2 byte charsets
outKey[start++] = (byte) (pos & 0xff);
}
return start;
}
}
/**
* A collator that works with this sort. This should be used if you just need to compare two
* strings against each other once.
*
* The sort key is better when the comparison must be done several times as in a sort operation.
*
* This implementation has the same effect when used for sorting as the sort keys.
*/
private class SrtCollator extends Collator {
private final int codepage;
private SrtCollator(int codepage) {
this.codepage = codepage;
}
public int compare(String source, String target) {
char[] chars1;
char[] chars2;
if (isMulti()) {
chars1 = source.toCharArray();
chars2 = target.toCharArray();
} else {
CharBuffer in1 = CharBuffer.wrap(source);
CharBuffer in2 = CharBuffer.wrap(target);
try {
byte[] bytes1 = encoder.encode(in1).array();
byte[] bytes2 = encoder.encode(in2).array();
chars1 = new char[bytes1.length];
for (int i = 0; i < bytes1.length; i++)
chars1[i] = (char) (bytes1[i] & 0xff);
chars2 = new char[bytes2.length];
for (int i = 0; i < bytes2.length; i++)
chars2[i] = (char) (bytes2[i] & 0xff);
} catch (CharacterCodingException e) {
throw new ExitException("character encoding failed unexpectedly", e);
}
}
int strength = getStrength();
int res = compareOneStrength(chars1, chars2, Collator.PRIMARY);
if (res == 0 && strength != PRIMARY) {
res = compareOneStrength(chars1, chars2, Collator.SECONDARY);
if (res == 0 && strength != SECONDARY) {
res = compareOneStrength(chars1, chars2, Collator.TERTIARY);
}
}
return res;
}
/**
* Compare the bytes against primary, secondary or tertiary arrays.
* @param char1 Bytes for the first string in the codepage encoding.
* @param char2 Bytes for the second string in the codepage encoding.
* @return Comparison result -1, 0 or 1.
*/
private int compareOneStrength(char[] char1, char[] char2, int type) {
int res = 0;
PositionIterator it1 = new PositionIterator(char1, type);
PositionIterator it2 = new PositionIterator(char2, type);
while (it1.hasNext() || it2.hasNext()) {
int p1 = it1.next();
int p2 = it2.next();
if (p1 < p2) {
res = -1;
break;
} else if (p1 > p2) {
res = 1;
break;
}
}
return res;
}
public CollationKey getCollationKey(String source) {
throw new UnsupportedOperationException("use Sort.createSortKey() instead");
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
SrtCollator that = (SrtCollator) o;
if (codepage != that.codepage) return false;
return true;
}
public int hashCode() {
return codepage;
}
class PositionIterator implements Iterator {
private final char[] chars;
private final int len;
private final int type;
private int pos;
private int expStart;
private int expEnd;
private int expPos;
PositionIterator(char[] chars, int type) {
this.chars = chars;
this.len = chars.length;
this.type = type;
}
public boolean hasNext() {
return pos < len || expPos != 0;
}
/**
* Get the next sort order value for the input string. Does not ever return values
* that are ignorable. Returns NO_ORDER at (and beyond) the end of the string, this
* value sorts less than any other and so makes shorter strings sort first.
* @return The next non-ignored sort position. At the end of the string it returns
* NO_ORDER.
*/
public Integer next() {
int next;
if (expPos == 0) {
do {
if (pos >= len) {
next = NO_ORDER;
break;
}
// Get the first non-ignorable at this level
int c = chars[(pos++ & 0xff)];
if (!hasPage(c >>> 8)) {
next = 0;
continue;
}
int nExpand = (getFlags(c) >> 4) & 0x3;
// Check if this is an expansion.
if (nExpand > 0) {
expStart = getPrimary(c) - 1;
expEnd = expStart + nExpand;
expPos = expStart;
next = expansions.get(expPos).getPosition(type);
if (++expPos > expEnd)
expPos = 0;
} else {
next = getPos(type, c);
}
} while (next == 0);
} else {
next = expansions.get(expPos).getPosition(type);
if (++expPos > expEnd)
expPos = 0;
}
return next;
}
public void remove() {
throw new UnsupportedOperationException("remove not supported");
}
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/MultiSortKey.java 0000644 0000764 0000764 00000002434 11607644250 023707 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
/**
* Combines a number of sort keys into one. The first is the primary sort and contains the
* actual object being sorted.
*
* @author Steve Ratcliffe
*/
public class MultiSortKey implements SortKey {
private final SortKey key1;
private final SortKey key2;
private final SortKey key3;
public MultiSortKey(SortKey key1, SortKey key2, SortKey key3) {
this.key1 = key1;
this.key2 = key2;
this.key3 = key3;
}
public T getObject() {
return key1.getObject();
}
public int compareTo(SortKey o) {
MultiSortKey other = (MultiSortKey) o;
int res = key1.compareTo(other.key1);
if (res == 0) {
res = key2.compareTo(other.key2);
if (res == 0 && key3 != null) {
res = key3.compareTo(other.key3);
}
}
return res;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/SrtSortKey.java 0000644 0000764 0000764 00000003304 12305453510 023353 0 ustar steve steve /*
* Copyright (C) 2010.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
import java.util.Arrays;
/**
* Sort key created from a Srt {@link Sort} object that allows strings to be compared according to that sorting
* scheme.
*
* @author Steve Ratcliffe
*/
class SrtSortKey implements SortKey {
private final T orig;
private final byte[] key;
private int second;
public SrtSortKey(T orig, byte[] key) {
this.orig = orig;
this.key = key;
}
public SrtSortKey(T orig, byte[] key, int second) {
this.orig = orig;
this.key = key;
this.second = second;
}
public int compareTo(SortKey o) {
SrtSortKey other = (SrtSortKey) o;
int length = Math.min(this.key.length, other.key.length);
for (int i = 0; i < length; i++) {
int k1 = this.key[i] & 0xff;
int k2 = other.key[i] & 0xff;
if (k1 < k2) {
return -1;
} else if (k1 > k2) {
return 1;
}
}
//if (this.key.length < other.key.length)
// return -1;
//else if (this.key.length > other.key.length)
// return 1;
if (second == other.second)
return 0;
else if (second < other.second)
return -1;
else
return 1;
}
public T getObject() {
return orig;
}
public String toString() {
return String.format("%s,%d", Arrays.toString(key), second);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/CodePosition.java 0000644 0000764 0000764 00000003005 12346663602 023671 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
import java.text.Collator;
/**
* Represents the collation positions of a given code point.
*
* @author Steve Ratcliffe
*/
class CodePosition {
private char primary;
private byte secondary;
private byte tertiary;
public char getPrimary() {
return primary;
}
public byte getSecondary() {
return secondary;
}
public byte getTertiary() {
return tertiary;
}
/**
* Get the position with the given strength.
*
* @param type The strength, Collator.PRIMARY, SECONDARY etc.
* @return The collation position at the given strength.
*/
public int getPosition(int type) {
switch (type) {
case Collator.PRIMARY:
return primary;
case Collator.SECONDARY:
return secondary & 0xff;
case Collator.TERTIARY:
return tertiary & 0xff;
default:
return 0;
}
}
public void setPrimary(char primary) {
this.primary = primary;
}
public void setSecondary(byte secondary) {
this.secondary = secondary;
}
public void setTertiary(byte tertiary) {
this.tertiary = tertiary;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/SortKey.java 0000644 0000764 0000764 00000002053 11532723256 022672 0 ustar steve steve /*
* Copyright (C) 2010.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
/**
* A sort key that allows efficient comparison of a string with a particular sorting order multiple times.
*
* The general idea is that you create a key for each object to be sorted and then sort the keys. Once the
* keys are sorted you retrieve the original object via the {@link #getObject} method.
*
* @author Steve Ratcliffe
*/
public interface SortKey extends Comparable> {
/**
* Get the object associated with this sort key.
* This will usually be the real object being sorted.
*/
public T getObject();
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/SRTHeader.java 0000644 0000764 0000764 00000012257 12346663602 023064 0 ustar steve steve /*
* Copyright (C) 2010.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
import uk.me.parabola.imgfmt.ReadFailedException;
import uk.me.parabola.imgfmt.app.CommonHeader;
import uk.me.parabola.imgfmt.app.ImgFileReader;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Section;
import uk.me.parabola.imgfmt.app.SectionWriter;
/**
* The header of the SRT file.
*
* This file determines the sort order of the label characters.
*
* @author Steve Ratcliffe
*/
public class SRTHeader extends CommonHeader {
// The header length we are using for the SRT file
private static final int HEADER_LEN = 29;
protected static final int HEADER2_LEN = 16;
protected static final int HEADER3_LEN = 52;
protected static final int HEADER3_MULTI_LEN = 92;
// The section structure of this file is somewhat different to other
// files, but I am still going to model it using Section.
private final Section header = new Section();
private final Section desc = new Section(header);
private final Section subheader = new Section(desc);
private final Section chartab = new Section((char) 3);
private final Section expansions = new Section(chartab, (char) 2);
private final Section srt8 = new Section(expansions, (char) 5);
private final Section srt7 = new Section(srt8, (char) 4);
private Sort sort;
public SRTHeader() {
super(HEADER_LEN, "GARMIN SRT");
header.setPosition(HEADER_LEN);
header.setSize(16);
chartab.setPosition(HEADER3_LEN);
}
protected void readFileHeader(ImgFileReader reader) throws ReadFailedException {
throw new UnsupportedOperationException("not implemented yet");
}
/**
* Write out the application header. This is unusual as it just points
* to an area which is itself just a header.
*/
protected void writeFileHeader(ImgFileWriter writer) {
writer.putChar((char) 1);
writer.putInt(header.getPosition());
writer.putChar((char) header.getSize());
}
/**
* Section writer to write the character and expansions sections. These two sections are embedded within another
* section and their offsets are relative to that section.
* @param writer The real underlying writer.
* @return A new writer where offsets are relative to the start of the sub-header section.
*/
SectionWriter makeSectionWriter(ImgFileWriter writer) {
return new SectionWriter(writer, subheader);
}
/**
* This is a header with pointers to the description and the main section.
* The offsets contained in this section are relative to the beginning of the file.
* @param writer Header is written here.
*/
protected void writeHeader2(ImgFileWriter writer) {
desc.writeSectionInfo(writer);
subheader.writeSectionInfo(writer);
}
/**
* Header contained within the main section. Offsets within this section are relative to the beginning
* of the section.
* @param writer Header is written here.
*/
protected void writeHeader3(ImgFileWriter writer) {
if (sort.isMulti()) {
writer.putChar((char) HEADER3_MULTI_LEN);
} else {
writer.putChar((char) HEADER3_LEN);
}
writer.putChar((char) sort.getId1());
writer.putChar((char) sort.getId2());
writer.putChar((char) sort.getCodepage());
if (sort.isMulti())
writer.putInt(0x6f02);
else
writer.putInt(0x2002);
chartab.writeSectionInfo(writer, true, true);
writer.putChar((char) 0);
expansions.writeSectionInfo(writer, true, true);
writer.putChar((char) 0);
// SRT6 A repeat pointer to the single byte character table
writer.putInt(chartab.getPosition());
writer.putInt(0);
if (sort.isMulti()) {
writer.putInt(1);
writer.putInt(sort.getMaxPage()); // max block in srt7
srt7.writeSectionInfo(writer, true);
writer.putChar((char) 0);
writer.putInt(0);
srt8.writeSectionInfo(writer, true);
writer.putChar((char) 0);
writer.putInt(0);
}
}
public void setSort(Sort sort) {
this.sort = sort;
if (sort.isMulti()) {
chartab.setPosition(HEADER3_MULTI_LEN);
chartab.setItemSize((char) 5);
expansions.setItemSize((char) 4);
}
}
/** Called after the description has been written to record the position. */
public void endDescription(int position) {
desc.setSize(position - desc.getPosition());
subheader.setPosition(position);
}
/** Called after the character table has been written to record the position. */
public void endCharTable(int position) {
chartab.setSize(position - chartab.getPosition());
}
/** Called after the expansions has been written to record the position. */
public void endTab2(int postition) {
subheader.setSize(postition - subheader.getPosition());
expansions.setSize(postition - expansions.getPosition());
}
public void endSrt8(int position) {
srt8.setSize(position - srt8.getPosition());
}
public void endSrt7(int position) {
srt7.setSize(position - srt7.getPosition());
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/package.html 0000644 0000764 0000764 00000002756 11330560764 022721 0 ustar steve steve
SRT File
This file is used to specify the character sorting order and which
characters are the 'same' for the purposes of searching. All accented versions
of a character will have the same code.
The first section has three byte records that have the following meaning
| Byte number |
Description |
| 1 |
The low nibble is 1 for letters, 2 for digits and zero for everything
else. |
| 2 |
This is the sort order for the unaccented form of the character.
So a, , , and would all have the same code here. The next byte allows
you to put them in order. |
| 3 |
Upper nibble is 2 for uppercase letters, 1 for lowercase letters.
It can also have the values 3 or 4 for unknown reasons.
The lower nibble is a number that can be added to byte 2 to get the full
sorting order. This sorts the accented versions of the characters |
The next section has two byte records with an unknown function.
Unknowns
At the time of writing Jan 2010 certain things are not known.
- If it can deal with character pairs that sort as one.
- What the second section is for.
- Sorting for scandinavian languages where the accented characters come at
the end of the alphabet. Perhaps you just treat them as separate letters and
not as a base + accent, or perhaps there is a way of specifying it.
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/IntegerSortKey.java 0000644 0000764 0000764 00000002462 11532723256 024214 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
/**
* Sort key when you are soring on a simple integer.
*
* @author Steve Ratcliffe
*/
public class IntegerSortKey implements SortKey {
private final T object;
private final int val;
private final int second;
public IntegerSortKey(T object, int val, int second) {
this.object = object;
this.val = val;
this.second = second;
}
/**
* Get the object associated with this sort key. This will usually be the real object being sorted.
*/
public T getObject() {
return object;
}
public int compareTo(SortKey o) {
IntegerSortKey other = (IntegerSortKey) o;
if (val == other.val) {
if (second == other.second)
return 0;
else if (second < other.second)
return -1;
else
return 1;
}
else if (val < other.val)
return -1;
else
return 1;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/srt/CombinedSortKey.java 0000644 0000764 0000764 00000003125 11613353647 024337 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.srt;
/**
* Allows you to combine another sort key with further integer comparisons.
* Avoids having to cram two integers into one when there is the possibility that
* they may not be enough bits to represent all values.
*
* @author Steve Ratcliffe
*/
public class CombinedSortKey implements SortKey {
private final SortKey key;
private final int first;
private final int second;
//public CombinedSortKey(SortKey key, int first) {
// this(key, first, 0);
//}
public CombinedSortKey(SortKey obj, int first, int second) {
this.key = obj;
this.first = first;
this.second = second;
}
public T getObject() {
return key.getObject();
}
public int compareTo(SortKey o) {
CombinedSortKey other = (CombinedSortKey) o;
int res = key.compareTo(other.key);
if (res == 0) {
res = compareInts(first, other.first);
if (res == 0) {
res = compareInts(second, other.second);
}
}
return res;
}
private int compareInts(int i1, int i2) {
int res;
if (i1 == i2)
res = 0;
else if (i1 < i2)
res = -1;
else
res = 1;
return res;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/ 0000755 0000764 0000764 00000000000 12651103763 020377 5 ustar steve steve mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr17.java 0000644 0000764 0000764 00000006044 11701624112 022127 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Name indexes consisting of a prefix of the string and the record
* number at which that prefix first occurs. So it is like 8 and 12
* except that they are all combined together in this one section.
*
* @author Steve Ratcliffe
*/
public class Mdr17 extends MdrSection {
private PrefixIndex streets;
private PrefixIndex streetsByCountry;
private PrefixIndex cities;
private PrefixIndex pois;
public Mdr17(MdrConfig config) {
setConfig(config);
streets = new PrefixIndex(getConfig(), 4);
streetsByCountry = new PrefixIndex(getConfig(), 4);
cities = new PrefixIndex(getConfig(), 2);
pois = new PrefixIndex(getConfig(), 4);
}
public void writeSectData(ImgFileWriter writer) {
writeSubSect(writer, streets);
writeSubSect(writer, cities);
writeSubSect(writer, streetsByCountry);
writeSubSect(writer, pois);
}
/**
* Write one of the subsections that makes up the section. They are all similar and
* have a header with the length and the record size and prefix length of the
* records in the subsection.
*/
private void writeSubSect(ImgFileWriter writer, PrefixIndex index) {
index.preWrite();
int len = index.getItemSize() * index.getNumberOfItems() + 2;
if (len == 2)
return; // nothing to do
// The length is a variable length integer with the length indicated by a suffix.
len = (len << 1) + 1;
int mask = ~0xff;
int count = 1;
while ((len & mask) != 0) {
mask <<= 8;
len <<= 1;
count++;
}
putN(writer, count, len);
// Calculate the header. This code is unlikely to survive the finding of another example!
// Have no idea what the real thinking behind this is.
int prefixLength = index.getPrefixLength();
int header = (prefixLength - 1) << 8;
header += (prefixLength + 1) * (prefixLength + 1);
header += (index.getItemSize() - prefixLength - 1) * 0xa;
writer.putChar((char) header);
index.writeSectData(writer);
}
protected void releaseMemory() {
streets = null;
cities = null;
streetsByCountry = null;
pois = null;
}
public void addStreets(List streetList) {
streets.createFromList(streetList);
}
public void addCities(List cityList) {
cities.createFromList(cityList);
}
public void addStreetsByCountry(List streets) {
streetsByCountry.createFromList(streets, true);
}
public void addPois(List poiList) {
pois.createFromList(poiList);
}
public int getItemSize() {
return 0;
}
protected int numberOfItems() {
return 0;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr6Record.java 0000644 0000764 0000764 00000002264 11713757443 023225 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import uk.me.parabola.imgfmt.app.lbl.Zip;
/**
* Holds information about a zip that will make its way into mdr 6.
*
* @author WanMil
*/
public class Mdr6Record extends RecordBase implements NamedRecord {
/** The zip index within its own map */
private final int zipIndex;
private final String name;
private int stringOffset;
public Mdr6Record(Zip zip) {
zipIndex = zip.getIndex();
name = zip.getLabel().getText();
}
public int getZipIndex() {
return zipIndex;
}
public String getName() {
return name;
}
public int getStringOffset() {
return stringOffset;
}
public void setStringOffset(int stringOffset) {
this.stringOffset = stringOffset;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr8Record.java 0000644 0000764 0000764 00000001737 11532723256 023225 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* This section is a simple index into the streets section (mdr7).
*
* @author Steve Ratcliffe
*/
public class Mdr8Record extends ConfigBase {
private String prefix;
private int recordNumber;
public String getPrefix() {
return prefix;
}
public void setPrefix(String prefix) {
this.prefix = prefix;
}
public int getRecordNumber() {
return recordNumber;
}
public void setRecordNumber(int recordNumber) {
this.recordNumber = recordNumber;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr29.java 0000644 0000764 0000764 00000007760 12325011461 022140 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* An index of countries sorted by name with pointers to the other country related sections.
* There is only one per name, not per name and map.
*
* @author Steve Ratcliffe
*/
public class Mdr29 extends MdrSection implements HasHeaderFlags {
private final List index = new ArrayList<>();
private int max17;
public Mdr29(MdrConfig config) {
setConfig(config);
}
public void buildFromCountries(List countries) {
Sort sort = getConfig().getSort();
List> keys = MdrUtils.sortList(sort, countries);
// Sorted by name, for every new name we allocate a new 29 record and set the same one in every
// country with the same name.
String lastName = null;
Mdr29Record mdr29 = null;
for (SortKey key : keys) {
Mdr14Record country = key.getObject();
String name = country.getName();
if (!name.equals(lastName)) {
mdr29 = new Mdr29Record();
mdr29.setName(name);
mdr29.setStrOffset(country.getStrOff());
index.add(mdr29);
lastName = name;
}
assert mdr29 != null;
country.setMdr29(mdr29);
}
}
protected void preWriteImpl() {
if (!index.isEmpty()) {
Mdr29Record r = index.get(index.size() - 1);
this.max17 = r.getMdr17();
}
}
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
int magic = getExtraValue();
boolean hasString = (magic & 1) != 0;
boolean has26 = (magic & 0x8) != 0;
boolean has17 = (magic & 0x30) != 0;
PointerSizes sizes = getSizes();
int size24 = sizes.getSize(24);
int size22 = sizes.getSize(22);
int size25 = sizes.getSize(5); // NB appears to be size of 5 (cities), not 25 (cities with country).
int size26 = has26? sizes.getSize(26): 0;
int size17 = numberToPointerSize(max17);
for (Mdr29Record record : index) {
putN(writer, size24, record.getMdr24());
if (hasString)
putStringOffset(writer, record.getStrOffset());
putN(writer, size22, record.getMdr22());
putN(writer, size25, record.getMdr25());
if (has26)
putN(writer, size26, record.getMdr26());
if (has17)
putN(writer, size17, record.getMdr17());
}
}
/**
* The size of a record in the section. This is not a constant and might vary
* on various factors, such as the file version, if we are preparing for a
* device, the number of maps etc.
*
* @return The size of a record in this section.
*/
public int getItemSize() {
PointerSizes sizes = getSizes();
int size = sizes.getSize(24)
+ sizes.getSize(22)
+ sizes.getSize(5) // NB: not 25
;
if (isForDevice()) {
size += numberToPointerSize(max17);
} else {
size += sizes.getStrOffSize();
size += sizes.getSize(26);
}
return size;
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return index.size();
}
/**
* Unknown flags.
*
* As there are 4 bits set and 4 extra fields, that might be it. Compare
* to mdr28 where there are 3 extra fields and 3 bits set. Just a guess...
*/
public int getExtraValue() {
if (isForDevice()) {
int magic = 0x6; // 22 and 25
magic |= numberToPointerSize(max17) << 4;
return magic; // +17, -26, -strings
}
else
return 0xf; // strings, 22, 25 and 26
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr29Record.java 0000644 0000764 0000764 00000003265 11701624112 023273 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* Holds the name and pointers to all the other country related sections for
* the given name.
*
* @author Steve Ratcliffe
*/
public class Mdr29Record {
private String name;
private int mdr24;
private int mdr22;
private int mdr25;
private int mdr26;
private int strOffset;
private int mdr17;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMdr24() {
return mdr24;
}
public void setMdr24(int mdr24) {
if (this.mdr24 == 0)
this.mdr24 = mdr24;
}
public int getMdr22() {
return mdr22;
}
public void setMdr22(int mdr22) {
if (this.mdr22 == 0)
this.mdr22 = mdr22;
}
public int getMdr25() {
return mdr25;
}
public void setMdr25(int mdr25) {
if (this.mdr25 == 0)
this.mdr25 = mdr25;
}
public int getMdr26() {
return mdr26;
}
public void setMdr26(int mdr26) {
if (this.mdr26 == 0)
this.mdr26 = mdr26;
}
public int getStrOffset() {
return strOffset;
}
public void setStrOffset(int strOffset) {
this.strOffset = strOffset;
}
public int getMdr17() {
return mdr17;
}
public void setMdr17(int mdr17) {
if (this.mdr17 == 0)
this.mdr17 = mdr17;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/MDRHeader.java 0000644 0000764 0000764 00000007323 11770652007 023003 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import uk.me.parabola.imgfmt.ReadFailedException;
import uk.me.parabola.imgfmt.app.CommonHeader;
import uk.me.parabola.imgfmt.app.ImgFileReader;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Section;
import uk.me.parabola.imgfmt.app.srt.Sort;
/**
* The header of the MDR file.
*
* Note that there are many possible sections in this file and that
* only a certain number of them are needed. There are also many
* different lengths for the record sizes of the sections. Finally
* there are different sections and record sizes for the version
* that gets loaded into the gmapsupp.
*
* @author Steve Ratcliffe
*/
public class MDRHeader extends CommonHeader {
private static final int MAX_SECTIONS = 40;
private final Section[] sections = new Section[MAX_SECTIONS+1];
private Sort sort;
public MDRHeader(int headerLen) {
super(headerLen, "GARMIN MDR");
// Do a quick initialisation. Link every section to the
// previous one so that all the positions are correct.
for (int i = 1; i < sections.length; i++) {
Section prev = (i == 0) ? null : sections[i - 1];
sections[i] = new Section(prev);
}
sections[1].setPosition(getHeaderLength());
}
protected void readFileHeader(ImgFileReader reader) throws ReadFailedException {
throw new UnsupportedOperationException("not implemented yet");
}
/**
* Write out the application header.
*/
protected void writeFileHeader(ImgFileWriter writer) {
writer.putChar((char) sort.getCodepage());
writer.putChar((char) sort.getId1());
writer.putChar((char) sort.getId2());
writer.putChar((char) 14);
sections[1].writeSectionInfo(writer, true, true);
sections[2].writeSectionInfo(writer, true, true);
sections[3].writeSectionInfo(writer, true, true);
sections[4].writeSectionInfo(writer, true, true);
sections[5].writeSectionInfo(writer, true, true);
sections[6].writeSectionInfo(writer, true, true);
sections[7].writeSectionInfo(writer, true, true);
sections[8].writeSectionInfo(writer, true, true);
sections[9].writeSectionInfo(writer, true, true);
sections[10].writeSectionInfo(writer, false, true);
sections[11].writeSectionInfo(writer, true, true);
sections[12].writeSectionInfo(writer, true, true);
sections[13].writeSectionInfo(writer, true, true);
sections[14].writeSectionInfo(writer, true, true);
sections[15].writeSectionInfo(writer);
writer.put((byte) 0);
sections[16].writeSectionInfo(writer, true, true);
sections[17].writeSectionInfo(writer, false, true);
for (int n = 18; n <= 30; n++)
sections[n].writeSectionInfo(writer, true, true);
}
public void setItemSize(int sectionNumber, int itemSize) {
Section section = sections[sectionNumber];
section.setItemSize((char) itemSize);
}
public void setExtraValue(int sectionNumber, int extraValue) {
Section section = sections[sectionNumber];
section.setExtraValue(extraValue);
}
public void setPosition(int sectionNumber, int position) {
sections[sectionNumber].setPosition(position);
}
public void setEnd(int sectionNumber, int position) {
Section s = sections[sectionNumber];
s.setSize(position - s.getPosition());
}
public Sort getSort() {
return sort;
}
public void setSort(Sort sort) {
this.sort = sort;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr13Record.java 0000644 0000764 0000764 00000003775 11532723256 023305 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* Information about a region.
* @author Steve Ratcliffe
*/
public class Mdr13Record extends RecordBase implements Comparable, NamedRecord {
private int regionIndex;
private int countryIndex;
private int lblOffset;
private int strOffset;
private String name;
private Mdr14Record mdr14;
private Mdr28Record mdr28;
/**
* We sort first by map id and then by region id.
*/
public int compareTo(Mdr13Record o) {
int v1 = (getMapIndex()<<16) + regionIndex;
int v2 = (o.getMapIndex()<<16) + o.regionIndex;
if (v1 < v2)
return -1;
else if (v1 > v2)
return 1;
else
return 0;
}
public int getRegionIndex() {
return regionIndex;
}
public void setRegionIndex(int regionIndex) {
this.regionIndex = regionIndex;
}
public int getStrOffset() {
return strOffset;
}
public void setStrOffset(int strOffset) {
this.strOffset = strOffset;
}
public void setCountryIndex(int countryIndex) {
this.countryIndex = countryIndex;
}
public int getCountryIndex() {
return countryIndex;
}
public int getLblOffset() {
return lblOffset;
}
public void setLblOffset(int lblOffset) {
this.lblOffset = lblOffset;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Mdr14Record getMdr14() {
return mdr14;
}
public void setMdr14(Mdr14Record mdr14) {
this.mdr14 = mdr14;
}
public Mdr28Record getMdr28() {
return mdr28;
}
public void setMdr28(Mdr28Record mdr28) {
this.mdr28 = mdr28;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/NamedRecord.java 0000644 0000764 0000764 00000001214 11532723256 023425 0 ustar steve steve /*
* Copyright (C) 2010.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* Marks a record that has a name.
*/
public interface NamedRecord {
public int getMapIndex();
public String getName();
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr15.java 0000644 0000764 0000764 00000007323 11701624112 022126 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import uk.me.parabola.imgfmt.ExitException;
import uk.me.parabola.imgfmt.MapFailedException;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* The string table. This is not used by the device.
*
* There is a compressed and non-compressed version of this section.
* We are starting with the regular string version.
*
* @author Steve Ratcliffe
*/
public class Mdr15 extends MdrSection {
private final OutputStream stringFile;
private int nextOffset;
private Map strings = new HashMap();
private final Charset charset;
private final File tempFile;
public Mdr15(MdrConfig config) {
setConfig(config);
charset = config.getSort().getCharset();
try {
tempFile = File.createTempFile("strings", null, config.getOutputDir());
tempFile.deleteOnExit();
stringFile = new BufferedOutputStream(new FileOutputStream(tempFile), 64 * 1024);
// reserve the string at offset 0 to be the empty string.
stringFile.write(0);
nextOffset = 1;
} catch (IOException e) {
throw new ExitException("Could not create temporary file");
}
}
public int createString(String str) {
Integer offset = strings.get(str);
if (offset != null)
return offset;
int off;
try {
off = nextOffset;
byte[] bytes = str.getBytes(charset);
stringFile.write(bytes);
stringFile.write(0);
// Increase offset for the length of the string and the null byte
nextOffset += bytes.length + 1;
} catch (IOException e) {
// Can't convert, return empty string instead.
off = 0;
}
strings.put(str, off);
return off;
}
/**
* Tidy up after reading files.
* Close the temporary file, and release the string table which is no longer
* needed.
*/
public void releaseMemory() {
strings = null;
try {
stringFile.close();
} catch (IOException e) {
throw new MapFailedException("Could not close string temporary file");
}
}
public void writeSectData(ImgFileWriter writer) {
FileInputStream stream = null;
try {
stream = new FileInputStream(tempFile);
FileChannel channel = stream.getChannel();
ByteBuffer buf = ByteBuffer.allocate(32 * 1024);
while (channel.read(buf) > 0) {
buf.flip();
writer.put(buf);
buf.compact();
}
} catch (IOException e) {
throw new ExitException("Could not write string section of index");
} finally {
Utils.closeFile(stream);
}
}
public int getItemSize() {
// variable sized records.
return 0;
}
/**
* The meaning of number of items for this section is the largest string
* offset possible. We are taking the total size of the string section
* for this.
*/
public int getSizeForRecord() {
return numberToPointerSize(nextOffset);
}
/**
* There is no use for this as the records are not fixed length.
*
* @return Always zero, could return the number of strings.
*/
protected int numberOfItems() {
return 0;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr21.java 0000644 0000764 0000764 00000004657 12325011461 022132 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* This section contains the streets sorted by region.
* There is no pointer from region, unlike in the case with cities.
*
* @author Steve Ratcliffe
*/
public class Mdr21 extends Mdr2x {
public Mdr21(MdrConfig config) {
setConfig(config);
}
/**
* We need to sort the streets by the name of their region. Within a region
* group the streets are ordered by their own index.
*
* @param inStreets The list of streets from mdr7.
*/
public void buildFromStreets(List inStreets) {
Sort sort = getConfig().getSort();
List> keys = new ArrayList<>();
Map cache = new HashMap<>();
for (Mdr7Record s : inStreets) {
Mdr5Record city = s.getCity();
if (city == null) continue;
Mdr13Record region = city.getMdrRegion();
if (region == null) continue;
String name = region.getName();
if (name == null)
continue;
keys.add(sort.createSortKey(s, name, s.getIndex(), cache));
}
Collections.sort(keys);
String lastName = null;
int lastMapid = 0;
int record = 0;
for (SortKey key : keys) {
Mdr7Record street = key.getObject();
String name = street.getName();
int mapid = street.getMapIndex();
if (mapid != lastMapid || !name.equals(lastName)) {
record++;
streets.add(street);
Mdr13Record mdrRegion = street.getCity().getMdrRegion();
if (mdrRegion != null) {
Mdr28Record mdr28 = mdrRegion.getMdr28();
mdr28.setMdr21(record);
}
lastMapid = mapid;
lastName = name;
}
}
}
protected boolean sameGroup(Mdr7Record street1, Mdr7Record street2) {
return true;
}
/**
* Not known what these flags signify.
*/
public int getExtraValue() {
return 0x11800;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/HasHeaderFlags.java 0000644 0000764 0000764 00000001665 11532723256 024055 0 ustar steve steve /*
* Copyright (C) 2008 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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 General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* @author Steve Ratcliffe
*/
public interface HasHeaderFlags {
/**
* Return the value that is put in the header after the section start, len
* and record size fields.
* At least in some cases this field controls what fields and/or size
* exist in the section.
* @return The correct value based on the contents of the section. Zero
* if nothing needs to be done.
*/
int getExtraValue();
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr27.java 0000644 0000764 0000764 00000005165 11642347335 022150 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* Cities sorted by region name.
*
* @author Steve Ratcliffe
*/
public class Mdr27 extends MdrSection {
private final List cities = new ArrayList();
public Mdr27(MdrConfig config) {
setConfig(config);
}
/**
* Cities are sorted by region and then by the mdr5 city record number.
* @param list The complete list of cities from mdr5.
*/
public void sortCities(List list) {
Sort sort = getConfig().getSort();
List> keys = new ArrayList>();
for (Mdr5Record c : list) {
Mdr13Record mdrRegion = c.getMdrRegion();
if (mdrRegion != null) {
SortKey key = sort.createSortKey(c, mdrRegion.getName(), c.getGlobalCityIndex());
keys.add(key);
}
}
Collections.sort(keys);
String lastName = null;
int record = 0;
for (SortKey key : keys) {
record++;
Mdr5Record city = key.getObject();
Mdr13Record mdrRegion = city.getMdrRegion();
Mdr28Record mdr28 = mdrRegion.getMdr28();
String name = mdr28.getName();
if (!name.equals(lastName)) {
mdr28.setMdr27(record);
lastName = name;
}
cities.add(city);
}
}
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
int size = getItemSize();
for (Mdr5Record city : cities) {
putN(writer, size, city.getGlobalCityIndex());
}
}
/**
* The size of a record in the section. This is not a constant and might vary
* on various factors, such as the file version, if we are preparing for a
* device, the number of maps etc.
*
* @return The size of a record in this section.
*/
public int getItemSize() {
return getSizes().getCitySize();
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return cities.size();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr7.java 0000644 0000764 0000764 00000022201 12551416073 022050 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.MapFailedException;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.MultiSortKey;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* The MDR 7 section is a list of all streets. Only street names are saved
* and so I believe that the NET section is required to make this work.
*
* @author Steve Ratcliffe
*/
public class Mdr7 extends MdrMapSection {
public static final int MDR7_HAS_STRING = 0x01;
public static final int MDR7_HAS_NAME_OFFSET = 0x20;
public static final int MDR7_PARTIAL_SHIFT = 6;
public static final int MDR7_U1 = 0x2;
public static final int MDR7_U2 = 0x4;
private static final int MAX_NAME_OFFSET = 127;
private final int codepage;
private final boolean isMulti;
private final boolean splitName;
private List allStreets = new ArrayList<>();
private List streets = new ArrayList<>();
private final int u2size = 1;
public Mdr7(MdrConfig config) {
setConfig(config);
Sort sort = config.getSort();
splitName = config.isSplitName();
codepage = sort.getCodepage();
isMulti = sort.isMulti();
}
public void addStreet(int mapId, String name, int lblOffset, int strOff, Mdr5Record mdrCity) {
if (name.isEmpty())
return;
// Find a name prefix, which is either a shield or a word ending 0x1e. We are treating
// a shield as a prefix of length one.
int prefix = 0;
if (name.charAt(0) < 7)
prefix = 1;
int sep = name.indexOf(0x1e);
if (sep > 0)
prefix = sep + 1;
// Find a name suffix which begins with 0x1f
sep = name.indexOf(0x1f);
int suffix = 0;
if (sep > 0)
suffix = sep;
// Large values can't actually work.
if (prefix >= MAX_NAME_OFFSET || suffix >= MAX_NAME_OFFSET)
return;
Mdr7Record st = new Mdr7Record();
st.setMapIndex(mapId);
st.setLabelOffset(lblOffset);
st.setStringOffset(strOff);
st.setName(name);
st.setCity(mdrCity);
st.setPrefixOffset((byte) prefix);
st.setSuffixOffset((byte) suffix);
allStreets.add(st);
if (!splitName)
return;
boolean start = false;
boolean inWord = false;
int c;
int outOffset = 0;
int end = Math.min((suffix > 0) ? suffix : name.length() - prefix - 1, MAX_NAME_OFFSET);
for (int nameOffset = 0; nameOffset < end; nameOffset += Character.charCount(c)) {
c = name.codePointAt(prefix + nameOffset);
// Don't use any word after a bracket
if (c == '(')
break;
if (!Character.isLetterOrDigit(c)) {
start = true;
inWord = false;
} else if (start && Character.isLetterOrDigit(c)) {
inWord = true;
}
if (start && inWord && outOffset > 0) {
st = new Mdr7Record();
st.setMapIndex(mapId);
st.setLabelOffset(lblOffset);
st.setStringOffset(strOff);
st.setName(name);
st.setCity(mdrCity);
st.setNameOffset((byte) nameOffset);
st.setOutNameOffset((byte) outOffset);
st.setPrefixOffset((byte) prefix);
st.setSuffixOffset((byte) suffix);
//System.out.println(st.getName() + ": add partial " + st.getPartialName());
allStreets.add(st);
start = false;
}
outOffset += outSize(c);
if (outOffset > MAX_NAME_OFFSET)
break;
}
}
/**
* Return the number of bytes that the given character will consume in the output encoded
* format.
*/
private int outSize(int c) {
if (codepage == 65001) {
// For unicode a simple lookup gives the number of bytes.
if (c < 0x80) {
return 1;
} else if (c <= 0x7FF) {
return 2;
} else if (c <= 0xFFFF) {
return 3;
} else if (c <= 0x10FFFF) {
return 4;
} else {
throw new MapFailedException(String.format("Invalid code point: 0x%x", c));
}
} else if (!isMulti) {
// The traditional single byte code-pages, always one byte.
return 1;
} else {
// Other multi-byte code-pages (eg ms932); can't currently create index for these anyway.
return 0;
}
}
/**
* Since we change the number of records by removing some after sorting,
* we sort and de-duplicate here.
* This is a performance critical part of the index creation process
* as it requires a lot of heap to store the sort keys.
*/
protected void preWriteImpl() {
Sort sort = getConfig().getSort();
List> sortedStreets = new ArrayList<>(allStreets.size());
for (Mdr7Record m : allStreets) {
sortedStreets.add(new MultiSortKey<>(
sort.createSortKey(m, m.getPartialName()),
sort.createSortKey(m, m.getInitialPart(), m.getMapIndex()),
null));
}
Collections.sort(sortedStreets);
// De-duplicate the street names so that there is only one entry
// per map for the same name.
int recordNumber = 0;
Mdr7Record last = new Mdr7Record();
for (int i = 0; i < sortedStreets.size(); i++){
SortKey sk = sortedStreets.get(i);
Mdr7Record r = sk.getObject();
if (r.getMapIndex() == last.getMapIndex()
&& r.getName().equals(last.getName()) // currently think equals is correct, not collator.compare()
&& r.getPartialName().equals(last.getPartialName()))
{
// This has the same name (and map number) as the previous one. Save the pointer to that one
// which is going into the file.
r.setIndex(recordNumber);
} else {
recordNumber++;
last = r;
r.setIndex(recordNumber);
streets.add(r);
}
// release memory
sortedStreets.set(i, null);
}
}
public void writeSectData(ImgFileWriter writer) {
String lastName = null;
String lastPartial = null;
boolean hasStrings = hasFlag(MDR7_HAS_STRING);
boolean hasNameOffset = hasFlag(MDR7_HAS_NAME_OFFSET);
for (Mdr7Record s : streets) {
addIndexPointer(s.getMapIndex(), s.getIndex());
putMapIndex(writer, s.getMapIndex());
int lab = s.getLabelOffset();
String name = s.getName();
if (!name.equals(lastName)) {
lab |= 0x800000;
lastName = name;
}
String partialName = s.getPartialName();
int trailingFlags = 0;
if (!partialName.equals(lastPartial)) {
trailingFlags |= 1;
lab |= 0x800000; // If it is not a partial repeat, then it is not a complete repeat either
}
lastPartial = partialName;
writer.put3(lab);
if (hasStrings)
putStringOffset(writer, s.getStringOffset());
if (hasNameOffset)
writer.put(s.getOutNameOffset());
putN(writer, u2size, trailingFlags);
}
}
/**
* For the map number, label, string (opt), and trailing flags (opt).
* The trailing flags are variable size. We are just using 1 now.
*/
public int getItemSize() {
PointerSizes sizes = getSizes();
int size = sizes.getMapSize() + 3 + u2size;
if (!isForDevice())
size += sizes.getStrOffSize();
if ((getExtraValue() & MDR7_HAS_NAME_OFFSET) != 0)
size += 1;
return size;
}
protected int numberOfItems() {
return streets.size();
}
/**
* Value of 3 possibly the existence of the lbl field.
*/
public int getExtraValue() {
int magic = MDR7_U1 | MDR7_HAS_NAME_OFFSET | (u2size << MDR7_PARTIAL_SHIFT);
if (isForDevice()) {
magic |= MDR7_U2;
} else {
magic |= MDR7_HAS_STRING;
}
return magic;
}
protected void releaseMemory() {
allStreets = null;
streets = null;
}
/**
* Must be called after the section data is written so that the streets
* array is already sorted.
* @return List of index records.
*/
public List getIndex() {
List list = new ArrayList<>();
for (int number = 1; number <= streets.size(); number += 10240) {
String prefix = getPrefixForRecord(number);
// need to step back to find the first...
int rec = number;
while (rec > 1) {
String p = getPrefixForRecord(rec);
if (!p.equals(prefix)) {
rec++;
break;
}
rec--;
}
Mdr8Record indexRecord = new Mdr8Record();
indexRecord.setPrefix(prefix);
indexRecord.setRecordNumber(rec);
list.add(indexRecord);
}
return list;
}
/**
* Get the prefix of the name at the given record.
* @param number The record number.
* @return The first 4 (or whatever value is set) characters of the street
* name.
*/
private String getPrefixForRecord(int number) {
Mdr7Record record = streets.get(number-1);
int endIndex = MdrUtils.STREET_INDEX_PREFIX_LEN;
String name = record.getName();
if (endIndex > name.length()) {
StringBuilder sb = new StringBuilder(name);
while (sb.length() < endIndex)
sb.append('\0');
name = sb.toString();
}
return name.substring(0, endIndex);
}
public List getStreets() {
return Collections.unmodifiableList(allStreets);
}
public List getSortedStreets() {
return Collections.unmodifiableList(streets);
}
public void relabelMaps(Mdr1 maps) {
relabel(maps, allStreets);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr23.java 0000644 0000764 0000764 00000005346 11642347335 022145 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* Regions sorted by name. Same number of records as mdr13.
*
* @author Steve Ratcliffe
*/
public class Mdr23 extends MdrSection {
private final List regions = new ArrayList();
public Mdr23(MdrConfig config) {
setConfig(config);
}
/**
* Takes the region list and sorts it according to the name.
* @param list Original region list.
*/
public void sortRegions(List list) {
Sort sort = getConfig().getSort();
List> keys = MdrUtils.sortList(sort, list);
Collections.sort(keys);
String lastName = null;
int lastMapIndex = 0;
int record = 0;
for (SortKey key : keys) {
Mdr13Record reg = key.getObject();
// Only add if different name or map
String name = reg.getName();
if (reg.getMapIndex() != lastMapIndex || !name.equals(lastName)) {
record++;
reg.getMdr28().setMdr23(record);
regions.add(reg);
lastName = name;
lastMapIndex = reg.getMapIndex();
}
}
}
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
String lastName = null;
for (Mdr13Record reg : regions) {
putMapIndex(writer, reg.getMapIndex());
int flag = 0;
String name = reg.getName();
if (!name.equals(lastName)) {
flag = 0x800000;
lastName = name;
}
writer.putChar((char) reg.getRegionIndex());
writer.putChar((char) reg.getCountryIndex());
writer.put3(reg.getLblOffset() | flag);
}
}
/**
* There is a map index followed by file region and country indexes.
* Then there is a label offset for the name, which strangely appears
* to be three bytes always, although that many would rarely (or never?) be
* required.
*/
public int getItemSize() {
PointerSizes sizes = getSizes();
return sizes.getMapSize() + 2 + 2 + 3;
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return regions.size();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr20.java 0000644 0000764 0000764 00000011043 12467220204 022120 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import uk.me.parabola.imgfmt.app.srt.MultiSortKey;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* This is a list of streets that belong to each city.
*
* It is sorted with each group of streets that belong to a city in the same
* order as the cities, within each group the sort is by street id in mdr7.
*
* Streets that do not have an associated city are not included.
*
* There is a subsection in the mdr1 reverse index for this section, however
* the map index is not saved as part of this record.
*
* @author Steve Ratcliffe
*/
public class Mdr20 extends Mdr2x {
public Mdr20(MdrConfig config) {
setConfig(config);
}
/**
* We need to sort the streets by the name of the city. Within a city
* group the streets are ordered by their own index.
*
* Also have to set the record number of the first record in this section
* on the city.
*
* @param inStreets The list of streets from mdr7, must have Mdr7.index set.
*/
public void buildFromStreets(List inStreets) {
Sort sort = getConfig().getSort();
// Use a key cache because there are a large number of street names but a much smaller number
// of city, region and country names. Therefore we can reuse the memory needed for the keys
// most of the time, particularly for the country and region names.
Map cache = new HashMap<>();
List> keys = new ArrayList<>();
for (Mdr7Record s : inStreets) {
Mdr5Record city = s.getCity();
if (city == null)
continue;
String name = city.getName();
if (name == null || name.isEmpty())
assert false;
// We are sorting the streets, but we are sorting primarily on the
// city name associated with the street, then on the street name.
SortKey cityKey = sort.createSortKey(s, city.getName(), 0, cache);
SortKey regionKey = sort.createSortKey(null, city.getRegionName(), 0, cache);
// The streets are already sorted, with the getIndex() method revealing the sort order
SortKey countryStreetKey = sort.createSortKey(null, city.getCountryName(), s.getIndex(),
cache);
// Combine all together so we can sort on it.
SortKey key = new MultiSortKey<>(cityKey, regionKey, countryStreetKey);
keys.add(key);
}
Collections.sort(keys);
Collator collator = getConfig().getSort().getCollator();
String lastName = null;
String lastPartialName = null;
Mdr5Record lastCity = null;
int record = 0;
int cityRecord = 1;
int lastMapNumber = 0;
for (SortKey key : keys) {
Mdr7Record street = key.getObject();
String name = street.getName();
String partialName = street.getPartialName();
Mdr5Record city = street.getCity();
boolean citySameByName = city.isSameByName(collator, lastCity);
int mapNumber = city.getMapIndex();
// Only save a single copy of each street name.
if (!citySameByName || mapNumber != lastMapNumber || lastName == null || lastPartialName == null
|| !name.equals(lastName)
|| !partialName.equals(lastPartialName))
{
record++;
streets.add(street);
lastName = name;
lastPartialName = partialName;
}
// The mdr20 value changes for each new city name
if (citySameByName) {
assert cityRecord!=0;
city.setMdr20(cityRecord);
} else {
// New city name, this marks the start of a new section in mdr20
assert cityRecord != 0;
cityRecord = record;
city.setMdr20(cityRecord);
lastCity = city;
}
lastMapNumber = mapNumber;
}
}
/**
* Two streets are in the same group if they have the same mdr20 id.
*/
protected boolean sameGroup(Mdr7Record street1, Mdr7Record street2) {
if (street2 != null && street1.getCity().getMdr20() == street2.getCity().getMdr20())
return true;
return false;
}
/**
* Unknown.
*/
public int getExtraValue() {
return isForDevice() ? 0xe : 0x8800;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr4Record.java 0000644 0000764 0000764 00000003156 11642347335 023220 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* The records in MDR 4 are a list of poi types with an unknown byte.
*/
public class Mdr4Record implements Comparable {
private int type;
private int subtype;
private int unknown;
public int compareTo(Mdr4Record o) {
int t1 = ((type<<8) + subtype) & 0xffff;
int t2 = ((o.type<<8) + o.subtype) & 0xffff;
if (t1 == t2)
return 0;
else if (t1 < t2)
return -1;
else
return 1;
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Mdr4Record that = (Mdr4Record) o;
if (subtype != that.subtype) return false;
if (type != that.type) return false;
return true;
}
public int hashCode() {
int result = type;
result = 31 * result + subtype;
return result;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public int getSubtype() {
return subtype;
}
public void setSubtype(int subtype) {
this.subtype = subtype;
}
public int getUnknown() {
return unknown;
}
public void setUnknown(int unknown) {
this.unknown = unknown;
}
} mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/PrefixIndex.java 0000644 0000764 0000764 00000010442 12325011461 023457 0 ustar steve steve /*
* Copyright (C) 2012.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.nio.charset.Charset;
import java.text.Collator;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
/**
* Holds an index of name prefixes to record numbers.
*
* Extends MdrSection, although is sometimes a subsection, not an actual section.
*
* @author Steve Ratcliffe
*/
public class PrefixIndex extends MdrSection {
private final int prefixLength;
private int maxIndex;
// We use mdr8record for all similar indexes.
private final List index = new ArrayList<>();
/**
* Sets the config and the prefix length for this index.
*
* Prefix length may differ depending on the amount of data, so will have
* to deal with that when it happens.
*
* @param config Configuration for sorting methods.
* @param prefixLength The prefix length for this index.
*/
public PrefixIndex(MdrConfig config, int prefixLength) {
setConfig(config);
this.prefixLength = prefixLength;
}
/**
* We can create an index for any type that has a name.
* @param list A list of items that have a name.
*/
public void createFromList(List list, boolean grouped) {
maxIndex = list.size();
// Prefixes are equal based on the primary unaccented character, so
// we need to use the collator to test for equality and not equals().
Sort sort = getConfig().getSort();
Collator collator = sort.getCollator();
collator.setStrength(Collator.PRIMARY);
String lastCountryName = null;
String lastPrefix = "";
int inRecord = 0; // record number of the input list
int outRecord = 0; // record number of the index
for (NamedRecord r : list) {
inRecord++;
String prefix = getPrefix(r.getName());
if (collator.compare(prefix, lastPrefix) != 0) {
outRecord++;
Mdr8Record ind = new Mdr8Record();
ind.setPrefix(prefix);
ind.setRecordNumber(inRecord);
index.add(ind);
lastPrefix = prefix;
if (grouped) {
// Peek into the real type to support the mdr17 feature of indexes sorted on country.
Mdr5Record city = ((Mdr7Record) r).getCity();
if (city != null) {
String countryName = city.getCountryName();
if (!countryName.equals(lastCountryName)) {
city.getMdrCountry().getMdr29().setMdr17(outRecord);
lastCountryName = countryName;
}
}
}
}
}
}
public void createFromList(List list) {
createFromList(list, false);
}
/**
* Write the section or subsection.
*/
public void writeSectData(ImgFileWriter writer) {
int size = numberToPointerSize(maxIndex);
Charset charset = getConfig().getSort().getCharset();
for (Mdr8Record s : index) {
writer.put(s.getPrefix().getBytes(charset), 0, prefixLength);
putN(writer, size, s.getRecordNumber());
}
}
public int getItemSize() {
return prefixLength + numberToPointerSize(maxIndex);
}
protected int numberOfItems() {
return index.size();
}
/**
* Get the prefix of the name at the given record.
* If the name is shorter than the prefix length, then it padded with nul characters.
* So it can be longer than the input string.
*
* @param in The name to truncate.
* @return A string prefixLength characters long, consisting of the initial
* prefix of name and padded with nulls if necessary to make up the length.
*/
private String getPrefix(String in) {
StringBuilder sb = new StringBuilder();
char[] chars = in.toCharArray();
int ci = 0;
for (int i = 0; i < prefixLength; i++) {
char c = 0;
while (ci < chars.length) {
// TODO: simplify when initial spaces are removed
c = chars[ci++];
if (ci == 1 && c== 0x20)
continue;
if (c >= 0x20)
break;
}
sb.append(c);
}
return sb.toString();
}
public int getPrefixLength() {
return prefixLength;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr18.java 0000644 0000764 0000764 00000002747 11701624112 022136 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* This is an index into 19 showing the start of each new type.
*
* Section 19 creates the data for this, we just write it out here.
*
* @author Steve Ratcliffe
*/
public class Mdr18 extends MdrSection implements HasHeaderFlags {
private List poiTypes = new ArrayList();
public Mdr18(MdrConfig config) {
setConfig(config);
}
public void writeSectData(ImgFileWriter writer) {
int poiSize = getSizes().getSize(19);
for (Mdr18Record pt : poiTypes) {
writer.putChar((char) (pt.getType() | 0x4000));
putN(writer, poiSize, pt.getRecord());
}
}
public int getItemSize() {
return 2 + getSizes().getSize(19);
}
protected int numberOfItems() {
return poiTypes.size();
}
public void setPoiTypes(List poiTypes) {
this.poiTypes = poiTypes;
}
public int getExtraValue() {
return 4 + getSizes().getSize(19)-1;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr11.java 0000644 0000764 0000764 00000010701 12325011461 022114 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.SortKey;
import uk.me.parabola.imgfmt.app.trergn.Point;
/**
* Holds all the POIs, including cities. Arranged alphabetically by
* the name.
*
* @author Steve Ratcliffe
*/
public class Mdr11 extends MdrMapSection {
private List pois = new ArrayList<>();
private Mdr10 mdr10;
public Mdr11(MdrConfig config) {
setConfig(config);
}
public Mdr11Record addPoi(int mapIndex, Point point, String name, int strOff) {
Mdr11Record poi = new Mdr11Record();
poi.setMapIndex(mapIndex);
poi.setPointIndex(point.getNumber());
poi.setSubdiv(point.getSubdiv().getNumber());
poi.setLblOffset(point.getLabel().getOffset());
poi.setName(name);
poi.setStrOffset(strOff);
pois.add(poi);
return poi;
}
/**
* Sort and fill in the mdr10 information.
*
* The POI index contains individual references to POI by subdiv and index, so they are not
* de-duplicated in the index in the same way that streets and cities are.
*/
protected void preWriteImpl() {
List> keys = MdrUtils.sortList(getConfig().getSort(), pois);
pois.clear();
for (SortKey sk : keys) {
Mdr11Record poi = sk.getObject();
mdr10.addPoiType(poi);
pois.add(poi);
}
}
public void writeSectData(ImgFileWriter writer) {
int count = 1;
boolean hasStrings = hasFlag(2);
for (Mdr11Record poi : pois) {
addIndexPointer(poi.getMapIndex(), count);
poi.setRecordNumber(count++);
putMapIndex(writer, poi.getMapIndex());
writer.put((byte) poi.getPointIndex());
writer.putChar((char) poi.getSubdiv());
writer.put3(poi.getLblOffset());
if (poi.isCity())
putRegionIndex(writer, poi.getRegionIndex());
else
putCityIndex(writer, poi.getCityIndex(), true);
if (hasStrings)
putStringOffset(writer, poi.getStrOffset());
}
}
public int getItemSize() {
PointerSizes sizes = getSizes();
int size = sizes.getMapSize() + 6 + sizes.getCitySizeFlagged();
if (hasFlag(0x2))
size += sizes.getStrOffSize();
return size;
}
protected int numberOfItems() {
return pois.size();
}
public int getNumberOfPois() {
return getNumberOfItems();
}
public int getExtraValue() {
int mdr11flags = 0x11;
PointerSizes sizes = getSizes();
// two bit field for city bytes. minimum size of 2
int citySize = sizes.getCitySizeFlagged();
if (citySize > 2)
mdr11flags |= (citySize-2) << 2;
if (isForDevice())
mdr11flags |= 0x80;
else
mdr11flags |= 0x2;
return mdr11flags;
}
public List getIndex() {
List list = new ArrayList<>();
for (int number = 1; number <= pois.size(); number += 10240) {
String prefix = getPrefixForRecord(number);
// need to step back to find the first...
int rec = number;
while (rec > 1) {
String p = getPrefixForRecord(rec);
if (!p.equals(prefix)) {
rec++;
break;
}
rec--;
}
Mdr12Record indexRecord = new Mdr12Record();
indexRecord.setPrefix(prefix);
indexRecord.setRecordNumber(rec);
list.add(indexRecord);
}
return list;
}
/**
* Get the prefix of the name at the given record.
* @param number The record number.
* @return The first 4 (or whatever value is set) characters of the street
* name.
*/
private String getPrefixForRecord(int number) {
Mdr11Record record = pois.get(number-1);
int endIndex = MdrUtils.POI_INDEX_PREFIX_LEN;
String name = record.getName();
if (endIndex > name.length()) {
StringBuilder sb = new StringBuilder(name);
while (sb.length() < endIndex)
sb.append('\0');
name = sb.toString();
}
return name.substring(0, endIndex);
}
public void setMdr10(Mdr10 mdr10) {
this.mdr10 = mdr10;
}
public void releaseMemory() {
pois = null;
mdr10 = null;
}
public List getPois() {
return new ArrayList<>(pois);
}
public void relabelMaps(Mdr1 maps) {
relabel(maps, pois);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/MdrUtils.java 0000644 0000764 0000764 00000006656 11701624112 023011 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* A bunch of static routines for use in creating the MDR file.
*/
public class MdrUtils {
public static final int STREET_INDEX_PREFIX_LEN = 4;
public static final int POI_INDEX_PREFIX_LEN = 4;
/**
* Get the group number for the poi. This is the first byte of the records
* in mdr9.
*
* Not entirely sure about how this works yet.
* @param fullType The primary type of the object.
* @return The group number. This is a number between 1 and 9 (and later
* perhaps higher numbers such as 0x40, so do not assume there are no
* gaps).
*/
public static int getGroupForPoi(int fullType) {
// We group pois based on their type. This may not be the final thoughts on this.
int type = MdrUtils.getTypeFromFullType(fullType);
int group = 0;
if (fullType < 0xf)
group = 1;
else if (type >= 0x2a && type <= 0x30) {
group = type - 0x28;
} else if (type == 0x28) {
group = 9;
}
return group;
}
public static boolean canBeIndexed(int fullType) {
return getGroupForPoi(fullType) != 0;
}
private static int getTypeFromFullType(int fullType) {
if ((fullType & 0xfff00) > 0)
return (fullType>>8) & 0xfff;
else
return fullType & 0xff;
}
/**
* Gets the subtype if there is one, else the type.
* @param fullType The type in the so-called 'full' format.
* @return If there is a subtype, then it is returned. Otherwise the type is returned.
*/
public static int getSubtypeOrTypeFromFullType(int fullType) {
return fullType & 0xff;
}
/**
* Sort records that are sorted by a name. They appropriate sort order will be used.
* @param sort The sort to be applied.
* @param list The list to be sorted.
* @param One of the Mdr?Record types that need to be sorted on a text field, eg street name.
* @return A list of sort keys in the sorted order. The original object is retrieved from the key
* by calling getObject().
*/
public static List> sortList(Sort sort, List list) {
List> toSort = new ArrayList>(list.size());
for (T m : list) {
SortKey sortKey = sort.createSortKey(m, m.getName(), m.getMapIndex());
toSort.add(sortKey);
}
Collections.sort(toSort);
return toSort;
}
/**
* The 'natural' type is always a combination of the type and subtype with the type
* shifted 5 bits and the sub type in the low 5 bits.
*
* For various reasons, we use 'fullType' in which the type is shifted up a full byte
* or is in the lower byte.
*
* @param ftype The so-called full type of the object.
* @return The natural type as defined above.
*/
public static int fullTypeToNaturalType(int ftype) {
int type = getTypeFromFullType(ftype);
int sub = 0;
if ((ftype & ~0xff) != 0)
sub = ftype & 0x1f;
return type << 5 | sub;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/MdrSection.java 0000644 0000764 0000764 00000013664 12325011461 023312 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Super class of all sections.
* @author Steve Ratcliffe
*/
public abstract class MdrSection extends ConfigBase {
private PointerSizes sizes;
private boolean released;
protected int nItems;
private boolean sizeValid;
/**
* Write out the contents of this section.
* @param writer Where to write it.
*/
public abstract void writeSectData(ImgFileWriter writer);
/**
* The size of a record in the section. This is not a constant and
* might vary on various factors, such as the file version, if we are
* preparing for a device, the number of maps etc.
*
* @return The size of a record in this section.
*/
public abstract int getItemSize();
protected PointerSizes getSizes() {
return sizes;
}
public void setSizes(PointerSizes sizes) {
this.sizes = sizes;
}
protected void putMapIndex(ImgFileWriter writer, int mapIndex) {
putN(writer, sizes.getMapSize(), mapIndex);
}
protected void putStringOffset(ImgFileWriter writer, int strOff) {
putN(writer, sizes.getStrOffSize(), strOff);
}
protected void putN(ImgFileWriter writer, int n, int value) {
switch (n) {
case 1:
writer.put((byte) value);
break;
case 2:
writer.putChar((char) value);
break;
case 3:
writer.put3(value);
break;
case 4:
writer.putInt(value);
break;
default: // Don't write anything.
assert false;
break;
}
}
protected static int numberToPointerSize(int n) {
if (n > 0xffffff)
return 4;
else if (n > 0xffff)
return 3;
else if (n > 0xff)
return 2;
else
return 1;
}
/**
* The number of records in this section.
* @return The number of items in the section.
*/
public final int getNumberOfItems() {
assert sizeValid;
if (released)
return nItems;
else
return numberOfItems();
}
/**
* Method to be implemented by subclasses to return the number of items in the section.
* This will only be valid after the section is completely finished etc.
* @return The number of items in the section.
*/
protected abstract int numberOfItems();
/**
* Get the size of an integer that is sufficient to store a record number
* from this section. If the pointer has a flag(s) then this must be
* taken into account too.
* @return A number between 1 and 4 giving the number of bytes required
* to store the largest record number in this section.
*/
public int getSizeForRecord() {
return numberToPointerSize(getNumberOfItems());
}
/**
* Called before the section is written and before the actual size of the section
* is required.
*
* Calling it more than once is ok.
*
* The actual work is implemented in the subclass via the {@link #preWriteImpl()} method.
*/
public final void preWrite() {
if (!sizeValid)
preWriteImpl();
sizeValid = true;
}
/**
* Prepare the final list of items to be written.
* Used to de-duplicate or remove invalid entries from the raw data that was
* saved.
*
* In particular after this call the number of items must not change.
*/
protected void preWriteImpl() {
}
public final void release() {
nItems = numberOfItems();
releaseMemory();
released = true;
}
protected void releaseMemory() {
throw new UnsupportedOperationException();
}
/**
* Provides the pointer sizes required to hold record of offset values
* in the various sections.
*/
static class PointerSizes {
private final MdrSection[] sections;
public PointerSizes(MdrSection[] sections) {
this.sections = sections;
}
public int getMapSize() {
return sections[1].getSizeForRecord();
}
public int getCitySize() {
return sections[5].getSizeForRecord();
}
/**
* Get the number of bytes required to represent a city when there is
* one bit reserved for a flag.
* There is a minimum size of 2.
* @return Number of bytes to represent a city record number and a
* one bit flag.
*/
public int getCitySizeFlagged() {
return Math.max(2, numberToPointerSize(sections[5].getNumberOfItems() << 1));
}
public int getCityFlag() {
return flagForSize(getCitySizeFlagged());
}
public int getStreetSize() {
return sections[7].getSizeForRecord();
}
public int getStreetSizeFlagged() {
return numberToPointerSize(sections[7].getNumberOfItems() << 1);
}
public int getPoiSize() {
return sections[11].getSizeForRecord();
}
public int getZipSize() {
//return Math.max(2, sections[6].getSizeForRecord());
return sections[6].getSizeForRecord();
}
/**
* The number of bytes required to represent a POI (mdr11) record number
* and a flag bit.
*/
public int getPoiSizeFlagged() {
return numberToPointerSize(sections[11].getNumberOfItems() << 1);
}
public int getPoiFlag() {
return flagForSize(getPoiSizeFlagged());
}
/**
* Size of the pointer required to index a byte offset into mdr15 (strings).
* There is a minimum of 3 for this value.
* @return Pointer size required for the string offset value.
*/
public int getStrOffSize() {
return Math.max(3, sections[15].getSizeForRecord());
}
public int getMdr20Size() {
return sections[20].getSizeForRecord();
}
private int flagForSize(int size) {
int flag;
if (size == 1)
flag = 0x80;
else if (size == 2)
flag = 0x8000;
else if (size == 3)
flag = 0x800000;
else if (size == 4)
flag = 0x80000000;
else
flag = 0;
return flag;
}
public int getSize(int sect) {
return sections[sect].getSizeForRecord();
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr28Record.java 0000644 0000764 0000764 00000003345 11532723256 023304 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* There is one of these for each region name (ie no repeats) there are indexes
* to the first entry with the same name in various other sections.
*
* @author Steve Ratcliffe
*/
public class Mdr28Record extends ConfigBase {
private int index;
private String name;
private int mdr21;
private int mdr23;
private int mdr27;
private int strOffset;
private Mdr14Record mdr14;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMdr21() {
return mdr21;
}
public void setMdr21(int mdr21) {
if (this.mdr21 == 0)
this.mdr21 = mdr21;
}
public int getMdr23() {
return mdr23;
}
public void setMdr23(int mdr23) {
if (this.mdr23 == 0)
this.mdr23 = mdr23;
}
public int getMdr27() {
return mdr27;
}
public void setMdr27(int mdr27) {
if (this.mdr27 == 0)
this.mdr27 = mdr27;
}
public int getStrOffset() {
return strOffset;
}
public void setStrOffset(int strOffset) {
this.strOffset = strOffset;
}
public Mdr14Record getMdr14() {
return mdr14;
}
public void setMdr14(Mdr14Record mdr14) {
this.mdr14 = mdr14;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/MdrConfig.java 0000644 0000764 0000764 00000004473 12467220204 023115 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.io.File;
import uk.me.parabola.imgfmt.app.srt.Sort;
/**
* Configuration for the MDR file.
* Mostly used when creating a file as there are a number of different options
* in the way that it is done.
*
* @author Steve Ratcliffe
*/
public class MdrConfig {
//private static final int DEFAULT_HEADER_LEN = 286;
private static final int DEFAULT_HEADER_LEN = 568;
private boolean writable;
private boolean forDevice;
private int headerLen = DEFAULT_HEADER_LEN;
private Sort sort;
private File outputDir;
private boolean splitName;
/**
* True if we are creating the file, rather than reading it.
*/
public boolean isWritable() {
return writable;
}
public void setWritable(boolean writable) {
this.writable = writable;
}
/**
* The format that is used by the GPS devices is different to that used
* by Map Source. This parameter says which to do.
* @return True if we are creating the the more compact format required
* for a device.
*/
public boolean isForDevice() {
return forDevice;
}
public void setForDevice(boolean forDevice) {
this.forDevice = forDevice;
}
/**
* There are a number of different header lengths in existence. This
* controls what sections can exist (and perhaps what must exist).
* @return The header length.
*/
public int getHeaderLen() {
return headerLen;
}
public void setHeaderLen(int headerLen) {
this.headerLen = headerLen;
}
public Sort getSort() {
return sort;
}
public void setSort(Sort sort) {
this.sort = sort;
}
public File getOutputDir() {
return outputDir;
}
public void setOutputDir(String outputDir) {
if (outputDir != null)
this.outputDir = new File(outputDir);
}
public void setSplitName(boolean splitName) {
this.splitName = splitName;
}
public boolean isSplitName() {
return splitName;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr12Record.java 0000644 0000764 0000764 00000001251 12571251757 023275 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* This is an index into mdr11 (pois).
* @author Steve Ratcliffe
*/
public class Mdr12Record extends Mdr8Record {
// This is exactly the same as mdr8
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr10.java 0000644 0000764 0000764 00000007330 12325011461 022117 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* POI subtype with a reference to MDR11.
* These are sorted into groups based on the type, and contain the
* subtype.
*
* The mdr9 section contains an index to this section based on the
* the type groups.
*
* @author Steve Ratcliffe
*/
public class Mdr10 extends MdrMapSection {
// The maximum group number. Note that this is 1 based, not 0 based.
private static final int MAX_GROUP_NUMBER = 9;
@SuppressWarnings({"unchecked"})
private List[] poiTypes = new ArrayList[MAX_GROUP_NUMBER+1];
private int numberOfPois;
public Mdr10(MdrConfig config) {
setConfig(config);
for (int i = 1; i <= MAX_GROUP_NUMBER; i++) {
poiTypes[i] = new ArrayList<>();
}
}
public void addPoiType(Mdr11Record poi) {
Mdr10Record t = new Mdr10Record();
int type = poi.getType();
t.setSubtype(MdrUtils.getSubtypeOrTypeFromFullType(type));
t.setMdr11ref(poi);
int group = MdrUtils.getGroupForPoi(type);
if (group == 0)
return;
poiTypes[group].add(t);
}
public void writeSectData(ImgFileWriter writer) {
int count = 0;
for (List poiGroup : poiTypes) {
if (poiGroup == null)
continue;
Collections.sort(poiGroup);
String lastName = null;
int lastSub = -1;
for (Mdr10Record t : poiGroup) {
count++;
Mdr11Record mdr11ref = t.getMdr11ref();
addIndexPointer(mdr11ref.getMapIndex(), count);
writer.put((byte) t.getSubtype());
int offset = mdr11ref.getRecordNumber();
// Top bit actually represents a non-repeated name. ie if
// the bit is not set, then the name is the same as the previous
// record.
String name = mdr11ref.getName();
boolean isNew = !(name.equals(lastName) && (t.getSubtype() == lastSub));
putPoiIndex(writer, offset, isNew);
lastName = name;
lastSub = t.getSubtype();
}
}
}
/**
* Get a list of the group sizes along with the group index number.
* @return A map that is guaranteed to iterate in the correct order for
* writing mdr9. The key is the group number and the value is the
* number of entries in that group.
*/
public Map getGroupSizes() {
Map m = new LinkedHashMap<>();
for (int i = 1; i < MAX_GROUP_NUMBER; i++) {
List poiGroup = poiTypes[i];
if (!poiGroup.isEmpty())
m.put(i, poiGroup.size());
}
return m;
}
/**
* This does not have a record size.
* @return Always zero to indicate that there is not a record size.
*/
public int getItemSize() {
return 0;
}
protected int numberOfItems() {
return numberOfPois;
}
public void setNumberOfPois(int numberOfPois) {
this.numberOfPois = numberOfPois;
}
protected void releaseMemory() {
poiTypes = null;
}
public int getExtraValue() {
// Nothing to do here
return 0;
}
/**
* Nothing to do for this section.
*
* Although this section has a subsection by map index in mdr1, its record does not contain the
* map index and so nothing needs to be re-written here. The map index is contained in its mdr11ref.
*/
public void relabelMaps(Mdr1 maps) {
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr18Record.java 0000644 0000764 0000764 00000001551 11701624112 023265 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* An index entry into mdr 19.
*
* @author Steve Ratcliffe
*/
public class Mdr18Record {
private int type;
private int record;
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public int getRecord() {
return record;
}
public void setRecord(int record) {
this.record = record;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/RecordBase.java 0000644 0000764 0000764 00000001567 12325011461 023253 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* Records that belong to a particular map should extend this class.
* Otherwise they can extend ConfigBase.
*
* @author Steve Ratcliffe
*/
public abstract class RecordBase {
private short mapIndex;
public int getMapIndex() {
return mapIndex;
}
public void setMapIndex(int mapIndex) {
assert mapIndex > 0;
this.mapIndex = (short) mapIndex;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr14.java 0000644 0000764 0000764 00000003244 11642347335 022140 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* The countries that occur in each map.
*
* @author Steve Ratcliffe
*/
public class Mdr14 extends MdrSection implements HasHeaderFlags {
private final List countries = new ArrayList();
public Mdr14(MdrConfig config) {
setConfig(config);
}
public void writeSectData(ImgFileWriter writer) {
Collections.sort(countries);
for (Mdr14Record country : countries) {
putMapIndex(writer, country.getMapIndex());
writer.putChar((char) country.getCountryIndex());
putStringOffset(writer, country.getStrOff());
}
}
public void addCountry(Mdr14Record country) {
countries.add(country);
}
public int getItemSize() {
PointerSizes sizes = getSizes();
return sizes.getMapSize() + 2 + sizes.getStrOffSize();
}
/**
* The number of records in this section.
* @return The number of items in the section.
*/
protected int numberOfItems() {
return countries.size();
}
public int getExtraValue() {
return 0x00;
}
public List getCountries() {
return countries;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr1Record.java 0000644 0000764 0000764 00000002162 11701624112 023174 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* @author Steve Ratcliffe
*/
public class Mdr1Record extends RecordBase {
private final int mapNumber;
private Mdr1MapIndex mdrMapIndex;
private int indexOffset;
public Mdr1Record(int mapNumber, MdrConfig config) {
this.mapNumber = mapNumber;
}
public int getMapNumber() {
return mapNumber;
}
public Mdr1MapIndex getMdrMapIndex() {
return mdrMapIndex;
}
public void setMdrMapIndex(Mdr1MapIndex mdrMapIndex) {
this.mdrMapIndex = mdrMapIndex;
}
public int getIndexOffset() {
return indexOffset;
}
public void setIndexOffset(int indexOffset) {
this.indexOffset = indexOffset;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr8.java 0000644 0000764 0000764 00000004476 11642347335 022073 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* This section is a simple index into the streets section (mdr7).
*
* @author Steve Ratcliffe
*/
public class Mdr8 extends MdrSection implements HasHeaderFlags {
private static final int STRING_WIDTH = 4;
private List index = new ArrayList();
public Mdr8(MdrConfig config) {
setConfig(config);
}
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
int size = associatedSize();
Charset charset = getConfig().getSort().getCharset();
for (Mdr8Record s : index) {
writer.put(s.getPrefix().getBytes(charset), 0, STRING_WIDTH);
putN(writer, size, s.getRecordNumber());
}
}
protected int associatedSize() {
return getSizes().getStreetSize();
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return index.size();
}
/**
* The size of a record in the section. This is not a constant and might vary
* on various factors, such as the file version, if we are preparing for a
* device, the number of maps etc.
*
* @return The size of a record in this section.
*/
public int getItemSize() {
return STRING_WIDTH + associatedSize();
}
public void setIndex(List index) {
this.index = index;
}
/**
* The header flags for the section.
* Possible values are not known.
*
* @return The correct value based on the contents of the section. Zero if
* nothing needs to be done.
*/
public int getExtraValue() {
// this value is likely to depend on the size of the max record number.
return (STRING_WIDTH << 8) + 0x0a;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/ConfigBase.java 0000644 0000764 0000764 00000001533 11332007627 023241 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* A base class that provides access to the MDR configuration data.
*/
public abstract class ConfigBase {
private MdrConfig config;
protected boolean isForDevice() {
return config.isForDevice();
}
public void setConfig(MdrConfig config) {
this.config = config;
}
protected MdrConfig getConfig() {
return config;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr5Record.java 0000644 0000764 0000764 00000010572 12306565326 023221 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.text.Collator;
/**
* Holds information about a city that will make its way into mdr 5.
* This class is used in several places as the information has to be gathered
* from the cities section of LBL and the points in RGN.
*
* @author Steve Ratcliffe
*/
public class Mdr5Record extends RecordBase implements NamedRecord {
/** The city index within its own map */
private int cityIndex;
/** The index across all maps */
private int globalCityIndex;
private int regionIndex;
private int lblOffset;
private int stringOffset;
private String name;
private Mdr13Record region;
private Mdr14Record country;
private int[] mdr20;
private int mdr20Index;
public int getCityIndex() {
return cityIndex;
}
public void setCityIndex(int cityIndex) {
this.cityIndex = cityIndex;
}
public int getGlobalCityIndex() {
return globalCityIndex;
}
public void setGlobalCityIndex(int globalCityIndex) {
this.globalCityIndex = globalCityIndex;
}
public int getRegionIndex() {
return regionIndex;
}
public void setRegionIndex(int regionIndex) {
this.regionIndex = regionIndex;
}
public int getLblOffset() {
return lblOffset;
}
public void setLblOffset(int lblOffset) {
this.lblOffset = lblOffset;
}
public int getStringOffset() {
return stringOffset;
}
public void setStringOffset(int stringOffset) {
this.stringOffset = stringOffset;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public Mdr13Record getMdrRegion() {
return region;
}
public void setMdrRegion(Mdr13Record region) {
this.region = region;
}
public Mdr14Record getMdrCountry() {
return country;
}
public void setMdrCountry(Mdr14Record country) {
this.country = country;
}
/**
* Every mdr5 record contains the same array of values. It is only
* allowed to access the one at the index globalCityIndex. Since
* the array is shared, every record with the same global city index
* knows the correct mdr20 value, regardless of where it was set.
*
* @param mdr20 An array large enough to hold all the cities (one based index).
* This must be the same array for all mdr5records (in the same map set).
*/
public void setMdr20set(int[] mdr20) {
this.mdr20 = mdr20;
}
/**
* Set the index into the mdr20 array that we use to get/set the value.
* @see #setMdr20set(int[])
*/
public void setMdr20Index(int mdr20Index) {
this.mdr20Index = mdr20Index;
}
public int getMdr20() {
return mdr20[mdr20Index];
}
public void setMdr20(int n) {
int prev = mdr20[mdr20Index];
assert prev == 0 || prev == n : "mdr20 value changed f=" + prev + " t=" + n + " count=" + mdr20Index;
mdr20[mdr20Index] = n;
}
/**
* Is this the same city, by the rules segregating the cities in mdr5 and 20.
* @return True if in the same tile and has the same name for city/region/country.
*/
public boolean isSameByMapAndName(Collator collator, Mdr5Record other) {
if (other == null)
return false;
return getMapIndex() == other.getMapIndex() && isSameByName(collator, other);
}
/**
* Same city by the name of the city/region/country combination.
*
* @param collator Used to sort names.
* @param other The other city to compare with.
* @return True if is the same city, maybe in a different tile.
*/
public boolean isSameByName(Collator collator, Mdr5Record other) {
if (other == null)
return false;
return collator.compare(getName(), other.getName()) == 0
&& collator.compare(getRegionName(), other.getRegionName()) == 0
&& collator.compare(getCountryName(), other.getCountryName()) == 0;
}
public String toString() {
return String.format("%d: %s r=%s c=%s", globalCityIndex, name, getRegionName(), country.getName());
}
public String getRegionName() {
if (region == null)
return "";
else
return region.getName();
}
public String getCountryName() {
return country.getName();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr12.java 0000644 0000764 0000764 00000001500 11532723256 022125 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* This is the index for the POI section (Mdr11).
* It works exactly the same way as Mdr8 as far as we know.
*
* @author Steve Ratcliffe
*/
public class Mdr12 extends Mdr8 {
public Mdr12(MdrConfig config) {
super(config);
}
protected int associatedSize() {
return getSizes().getPoiSize();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/MdrMapSection.java 0000644 0000764 0000764 00000006101 12325011461 023734 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Super class of all sections that contain items that belong to a particular
* map.
*
* @author Steve Ratcliffe
*/
public abstract class MdrMapSection extends MdrSection implements HasHeaderFlags {
private Mdr1 index;
public void setMapIndex(Mdr1 index) {
this.index = index;
}
/**
* This is called before the sections are written out, but after all the
* data is read into them.
* @param sectionNumber The one-based section number.
*/
public final void initIndex(int sectionNumber) {
// Set the size required to store the record numbers for this section.
// There are no flags or minimums required here, unlike in setPointerSize()
// which does a similar thing.
int n = getNumberOfItems();
index.setPointerSize(sectionNumber, numberToPointerSize(n));
}
/**
* Add a pointer to the reverse index for this section.
* @param recordNumber A record number in this section, belonging to the
* given map.
*/
public void addIndexPointer(int mapNumber, int recordNumber) {
if (!isForDevice())
index.addPointer(mapNumber, recordNumber);
}
protected void putCityIndex(ImgFileWriter writer, int cityIndex, boolean isNew) {
int flag = (isNew && cityIndex > 0)? getSizes().getCityFlag(): 0;
putN(writer, getSizes().getCitySizeFlagged(), cityIndex | flag);
}
protected void putRegionIndex(ImgFileWriter writer, int region) {
// This is only called when putCityIndex might also be called and so has to be
// the same size (probably ;)
putN(writer, getSizes().getCitySizeFlagged(), region);
}
protected void putPoiIndex(ImgFileWriter writer, int poiIndex, boolean isNew) {
int flag = isNew? getSizes().getPoiFlag(): 0;
putN(writer, getSizes().getPoiSizeFlagged(), poiIndex | flag);
}
protected boolean hasFlag(int val) {
return (getExtraValue() & val) != 0;
}
public abstract void relabelMaps(Mdr1 maps);
/**
* Relabel every map-index in the given set of records.
*
* The maps must be in sorted order, but because of the incremental way that we build the
* index, this isn't known until the end. So we get rewrite the mapIndex from the
* initial to the final ordering.
*
* @param maps The final ordering of the maps.
* @param records The set of records to be relabeled.
* @param The type of the record. Must be a subclass of RecordBase.
*/
protected void relabel(Mdr1 maps, List records) {
for (T r : records) {
int n = r.getMapIndex();
int newIndex = maps.sortedMapIndex(n);
r.setMapIndex(newIndex);
}
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr26.java 0000644 0000764 0000764 00000005207 11701624112 022127 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* An index into mdr28 (region names), sorted by country name.
*
* @author Steve Ratcliffe
*/
public class Mdr26 extends MdrSection {
private final List index = new ArrayList();
public Mdr26(MdrConfig config) {
setConfig(config);
}
public void sortMdr28(List in) {
Sort sort = getConfig().getSort();
List> sortList = new ArrayList>();
int record = 0;
for (Mdr28Record mdr28 : in) {
SortKey key = sort.createSortKey(mdr28, mdr28.getMdr14().getName(), ++record);
sortList.add(key);
}
Collections.sort(sortList);
addToIndex(sortList);
}
private void addToIndex(List> sortList) {
String lastName = null;
int record26 = 0;
for (SortKey key : sortList) {
record26++;
Mdr28Record mdr28 = key.getObject();
Mdr14Record mdr14 = mdr28.getMdr14();
assert mdr14 != null;
// For each new name, set up the mdr29 record for it.
String name = mdr14.getName();
if (!name.equals(lastName)) {
Mdr29Record mdr29 = mdr14.getMdr29();
mdr29.setMdr26(record26);
lastName = name;
}
index.add(mdr28);
}
}
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
int size = getSizes().getSize(28);
for (Mdr28Record record : index) {
putN(writer, size, record.getIndex());
}
}
/**
* The size of a record in the section. This is not a constant and might vary
* on various factors, such as the file version, if we are preparing for a
* device, the number of maps etc.
*
* @return The size of a record in this section.
*/
public int getItemSize() {
return getSizes().getSize(28);
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return index.size();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr22.java 0000644 0000764 0000764 00000005460 12467220204 022130 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* Index of streets by country.
*
* There is no pointer from the country section into this like there is with
* cities.
*
* @author Steve Ratcliffe
*/
public class Mdr22 extends Mdr2x {
public Mdr22(MdrConfig config) {
setConfig(config);
}
/**
* We need to sort the streets by the name of the country. Within a city
* group the streets are ordered by their own index.
*
* Also have to set the record number of the first record in this section
* on the city.
*
* @param inStreets The list of streets from mdr7.
*/
public void buildFromStreets(List inStreets) {
Sort sort = getConfig().getSort();
List> keys = new ArrayList<>();
Map cache = new HashMap<>();
for (Mdr7Record s : inStreets) {
Mdr5Record city = s.getCity();
if (city == null) continue;
String name = city.getMdrCountry().getName();
assert name != null;
// We are sorting the streets, but we are sorting primarily on the
// country name associated with the street.
// For memory use, we re-use country name part of the key.
keys.add(sort.createSortKey(s, name, s.getIndex(), cache));
}
Collections.sort(keys);
int record = 0;
String lastName = null;
int lastMapid = 0;
for (SortKey key : keys) {
Mdr7Record street = key.getObject();
String name = street.getName();
int mapid = street.getMapIndex();
if (mapid != lastMapid || !name.equals(lastName)) {
record++;
streets.add(street);
// Include in the mdr29 index if we have one for this record.
Mdr14Record mdrCountry = street.getCity().getMdrCountry();
if (mdrCountry != null) {
Mdr29Record mdr29 = mdrCountry.getMdr29();
mdr29.setMdr22(record);
}
lastMapid = mapid;
lastName = name;
}
}
}
protected boolean sameGroup(Mdr7Record street1, Mdr7Record street2) {
return true;
}
public List getStreets() {
return Collections.unmodifiableList(streets);
}
/**
* Unknown flag
*/
public int getExtraValue() {
if (isForDevice())
return 0x600e;
else
return 0x11000;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr5.java 0000644 0000764 0000764 00000013224 12325011461 022042 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.MultiSortKey;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* Section containing cities.
*
* We need: map number, city index in map, offset in LBL, flags
* and pointer into MDR 15 for the string name.
*
* @author Steve Ratcliffe
*/
public class Mdr5 extends MdrMapSection {
private List allCities = new ArrayList<>();
private List cities = new ArrayList<>();
private int maxCityIndex;
private int localCitySize;
public Mdr5(MdrConfig config) {
setConfig(config);
}
public void addCity(Mdr5Record record) {
assert record.getMapIndex() != 0;
allCities.add(record);
if (record.getCityIndex() > maxCityIndex)
maxCityIndex = record.getCityIndex();
}
/**
* Called after all cities to sort and number them.
*/
public void preWriteImpl() {
localCitySize = numberToPointerSize(maxCityIndex + 1);
List> sortKeys = new ArrayList<>(allCities.size());
Sort sort = getConfig().getSort();
for (Mdr5Record m : allCities) {
if (m.getName() == null)
continue;
// Sort by city name, region name, country name and map index.
SortKey sortKey = sort.createSortKey(m, m.getName());
SortKey regionKey = sort.createSortKey(null, m.getRegionName());
SortKey countryKey = sort.createSortKey(null, m.getCountryName(), m.getMapIndex());
sortKey = new MultiSortKey<>(sortKey, regionKey, countryKey);
sortKeys.add(sortKey);
}
Collections.sort(sortKeys);
Collator collator = getConfig().getSort().getCollator();
int count = 0;
Mdr5Record lastCity = null;
// We need a common area to save the mdr20 values, since there can be multiple
// city records with the same global city index
int[] mdr20s = new int[sortKeys.size()+1];
int mdr20count = 0;
for (SortKey key : sortKeys) {
Mdr5Record c = key.getObject();
c.setMdr20set(mdr20s);
if (!c.isSameByName(collator, lastCity))
mdr20count++;
c.setMdr20Index(mdr20count);
if (c.isSameByMapAndName(collator, lastCity)) {
c.setGlobalCityIndex(count);
} else {
count++;
c.setGlobalCityIndex(count);
cities.add(c);
lastCity = c;
}
}
}
public void writeSectData(ImgFileWriter writer) {
int size20 = getSizes().getMdr20Size();
Mdr5Record lastCity = null;
boolean hasString = hasFlag(0x8);
boolean hasRegion = hasFlag(0x4);
Collator collator = getConfig().getSort().getCollator();
for (Mdr5Record city : cities) {
int gci = city.getGlobalCityIndex();
addIndexPointer(city.getMapIndex(), gci);
// Work out if the name is the same as the previous one and set
// the flag if so.
int flag = 0;
int mapIndex = city.getMapIndex();
int region = city.getRegionIndex();
// Set the no-repeat flag if the name/region is different
if (!city.isSameByName(collator, lastCity)) {
flag = 0x800000;
lastCity = city;
}
// Write out the record
putMapIndex(writer, mapIndex);
putLocalCityIndex(writer, city.getCityIndex());
writer.put3(flag | city.getLblOffset());
if (hasRegion)
writer.putChar((char) region);
if (hasString)
putStringOffset(writer, city.getStringOffset());
putN(writer, size20, city.getMdr20());
}
}
/**
* Put the map city index. This is the index within the individual map
* and not the global city index used in mdr11.
*/
private void putLocalCityIndex(ImgFileWriter writer, int cityIndex) {
if (localCitySize == 2) // 3 probably not possible in actual maps.
writer.putChar((char) cityIndex);
else
writer.put((byte) cityIndex);
}
/**
* Base size of 8, plus enough bytes to represent the map number
* and the city number.
* @return The size of a record in this section.
*/
public int getItemSize() {
PointerSizes sizes = getSizes();
int size = sizes.getMapSize()
+ localCitySize
+ 3
+ sizes.getMdr20Size();
if (hasFlag(0x4))
size += 2;
if (hasFlag(0x8))
size += sizes.getStrOffSize();
return size;
}
protected int numberOfItems() {
return cities.size();
}
/**
* Known structure:
* bits 0-1: size of local city index - 1 (all values appear to work)
* bit 3: has region
* bit 4: has string
* @return The value to be placed in the header.
*/
public int getExtraValue() {
int val = (localCitySize - 1);
// String offset is only included for a mapsource index.
if (isForDevice()) {
val |= 0x40; // not known, probably refers to mdr17.
} else {
val |= 0x04; // region
val |= 0x08; // string
}
val |= 0x10;
val |= 0x100; // mdr20 present
return val;
}
protected void releaseMemory() {
allCities = null;
cities = null;
}
/**
* Get a list of all the cities, including duplicate named ones.
* @return All cities.
*/
public List getCities() {
return Collections.unmodifiableList(allCities);
}
public List getSortedCities() {
return Collections.unmodifiableList(cities);
}
public void relabelMaps(Mdr1 maps) {
relabel(maps, cities);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr14Record.java 0000644 0000764 0000764 00000003415 11532723256 023275 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* A country record.
* @author Steve Ratcliffe
*/
public class Mdr14Record extends RecordBase implements Comparable, NamedRecord {
private int countryIndex;
private int lblOffset;
private int strOff;
private String name;
private Mdr29Record mdr29;
/**
* Sort by map id and then country id like for regions. We don't have
* any evidence that this is necessary, but it would be surprising if
* it wasn't.
*/
public int compareTo(Mdr14Record o) {
int v1 = (getMapIndex()<<16) + countryIndex;
int v2 = (o.getMapIndex()<<16) + o.countryIndex;
if (v1 < v2)
return -1;
else if (v1 > v2)
return 1;
else
return 0;
}
public int getCountryIndex() {
return countryIndex;
}
public void setCountryIndex(int countryIndex) {
this.countryIndex = countryIndex;
}
public int getLblOffset() {
return lblOffset;
}
public void setLblOffset(int lblOffset) {
this.lblOffset = lblOffset;
}
public int getStrOff() {
return strOff;
}
public void setStrOff(int strOff) {
this.strOff = strOff;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Mdr29Record getMdr29() {
return mdr29;
}
public void setMdr29(Mdr29Record mdr29) {
this.mdr29 = mdr29;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr11Record.java 0000644 0000764 0000764 00000004156 11532723256 023275 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* The details required to write a POI record to mdr 11.
* @author Steve Ratcliffe
*/
public class Mdr11Record extends RecordBase implements NamedRecord {
private int pointIndex;
private int subdiv;
private int lblOffset;
private int strOffset;
private int recordNumber;
private String name;
private Mdr5Record city;
private boolean isCity;
private int type;
public boolean isCity() {
return isCity;
}
public void setIsCity(boolean isCity) {
this.isCity = isCity;
}
public int getPointIndex() {
return pointIndex;
}
public void setPointIndex(int pointIndex) {
this.pointIndex = pointIndex;
}
public int getSubdiv() {
return subdiv;
}
public void setSubdiv(int subdiv) {
this.subdiv = subdiv;
}
public int getLblOffset() {
return lblOffset;
}
public void setLblOffset(int lblOffset) {
this.lblOffset = lblOffset;
}
public int getCityIndex() {
return city == null ? 0 : city.getGlobalCityIndex();
}
public int getRegionIndex() {
return city == null ? 0 : city.getRegionIndex();
}
public int getStrOffset() {
return strOffset;
}
public void setStrOffset(int strOffset) {
this.strOffset = strOffset;
}
public int getRecordNumber() {
return recordNumber;
}
public void setRecordNumber(int recordNumber) {
this.recordNumber = recordNumber;
}
public String getName() {
assert name!=null;
return name;
}
public void setName(String name) {
assert name!=null;
this.name = name;
}
public void setCity(Mdr5Record city) {
this.city = city;
}
public void setType(int type) {
this.type = type;
}
public int getType() {
return type;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr1SubHeader.java 0000644 0000764 0000764 00000004234 11532723256 023635 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Section;
/**
* A header for the map index, pointed to from MDR 1.
* There is one of these for each map.
*
* @author Steve Ratcliffe
*/
public class Mdr1SubHeader {
// The number of subsections, this starts at 1. Larger numbers are possible
// for larger MDR header sizes.
private static final int MAX_SECTION = 9;
// Each sub header requires 8 bytes apart from sub2 which only needs 4.
private static final int HEADER_SIZE = 70;
private final Section[] sections = new Section[MAX_SECTION+1];
public Mdr1SubHeader() {
// Initialise the sections.
for (int n = 1; n <= MAX_SECTION; n++) {
Section prev = sections[n - 1];
sections[n] = new Section(prev);
}
sections[1].setPosition(HEADER_SIZE);
}
protected void writeFileHeader(ImgFileWriter writer) {
writer.putChar((char) HEADER_SIZE);
for (int n = 1; n <= MAX_SECTION; n++) {
Section section = sections[n];
// The second subsection does not have a length, because it always
// has the same length as subsection 1.
if (n == 2)
writer.putInt(section.getPosition());
else {
//section.writeSectionInfo(writer);
writer.putInt(section.getPosition());
int size = section.getSize();
if (size == 0)
writer.putInt(0);
else
writer.putInt(size / section.getItemSize());
}
}
}
public void setEndSubsection(int sub, int pos) {
sections[sub].setSize(pos - sections[sub].getPosition());
}
public long getHeaderLen() {
return HEADER_SIZE;
}
public void setItemSize(int sectionNumber, int itemSize) {
sections[sectionNumber].setItemSize((char) itemSize);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr10Record.java 0000644 0000764 0000764 00000002677 12325011461 023267 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* An index into mdr11.
* There is a primary ordering on the type and a secondary ordering on the
* record number of the mdr11 record. The type is not actually stored
* in this section, you use mdr9 to divide up this section into groups of
* types.
*
* This section contains the subtype of each point.
*
* @author Steve Ratcliffe
*/
public class Mdr10Record implements Comparable {
private int subtype;
private Mdr11Record mdr11ref;
public int compareTo(Mdr10Record o) {
if (mdr11ref.getRecordNumber() == o.mdr11ref.getRecordNumber())
return 0;
else if (mdr11ref.getRecordNumber() < o.mdr11ref.getRecordNumber())
return -1;
else
return 1;
}
public Mdr11Record getMdr11ref() {
return mdr11ref;
}
public void setMdr11ref(Mdr11Record mdr11ref) {
this.mdr11ref = mdr11ref;
}
public int getSubtype() {
return subtype;
}
public void setSubtype(int subtype) {
this.subtype = subtype;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr4.java 0000644 0000764 0000764 00000003502 11642347335 022054 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* POI types. A simple list of the types that are used?
* If you have this section, then the ability to select POI categories
* goes away.
*
* @author Steve Ratcliffe
*/
public class Mdr4 extends MdrSection implements HasHeaderFlags {
private final Set poiTypes = new HashSet();
public Mdr4(MdrConfig config) {
setConfig(config);
}
public void writeSectData(ImgFileWriter writer) {
List list = new ArrayList(poiTypes);
Collections.sort(list);
for (Mdr4Record r : list) {
writer.put((byte) r.getType());
writer.put((byte) r.getUnknown());
writer.put((byte) r.getSubtype());
}
}
public int getItemSize() {
return 3;
}
public void addType(int type) {
Mdr4Record r = new Mdr4Record();
if (type <= 0xff)
r.setType(type);
else {
r.setType((type >> 8) & 0xff);
r.setSubtype(type & 0xff);
}
r.setUnknown(0);
poiTypes.add(r);
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return poiTypes.size();
}
public int getExtraValue() {
return 0x00;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr19.java 0000644 0000764 0000764 00000006571 11770652007 022150 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* POIs ordered by type. Section 18 is the index into this.
*
* @author Steve Ratcliffe
*/
public class Mdr19 extends MdrSection implements HasHeaderFlags {
private List pois;
private final List poiTypes = new ArrayList();
public Mdr19(MdrConfig config) {
setConfig(config);
}
/**
* Sort the pois by type.
*/
public void preWriteImpl() {
Collections.sort(pois, new Comparator() {
public int compare(Mdr11Record o1, Mdr11Record o2) {
// For mainly historical reasons, we keep the element type in a number of different
// formats. Need to normalise it before sorting.
int t1 = MdrUtils.fullTypeToNaturalType(o1.getType());
int t2 = MdrUtils.fullTypeToNaturalType(o2.getType());
if (t1 == t2) return 0;
else if (t1 < t2) return -1;
else return 1;
}
});
}
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
int n = getSizes().getPoiSizeFlagged();
int flag = getSizes().getPoiFlag();
String lastName = null;
int lastType = -1;
int record = 1;
for (Mdr11Record p : pois) {
int index = p.getRecordNumber();
String name = p.getName();
if (!name.equals(lastName)) {
index |= flag;
lastName = name;
}
putN(writer, n, index);
int type = MdrUtils.fullTypeToNaturalType(p.getType());
if (type != lastType) {
Mdr18Record mdr18 = new Mdr18Record();
mdr18.setType(type);
mdr18.setRecord(record);
poiTypes.add(mdr18);
lastType = type;
}
record++;
}
Mdr18Record m18 = new Mdr18Record();
m18.setRecord(record);
m18.setType(~0);
poiTypes.add(m18);
}
/**
* Release the copy of the pois. The other index is small and not worth
* worrying about.
*/
protected void releaseMemory() {
pois = null;
}
/**
* Records in this section are record numbers into mdr 11 with a flag
* so has to be large enough for a flagged index.
*
* @return The size of a record in this section.
*/
public int getItemSize() {
return getSizes().getPoiSizeFlagged();
}
/**
* Method to be implemented by subclasses to return the number of items in the section. This will only be valid after
* the section is completely finished etc.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return pois.size();
}
/**
* Not yet known.
*
* @return The correct value based on the contents of the section. Zero if nothing needs to be done.
*/
public int getExtraValue() {
return getSizes().getSize(19) - 1;
}
public void setPois(List pois) {
this.pois = pois;
}
public List getPoiTypes() {
return poiTypes;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/package.html 0000644 0000764 0000764 00000000731 11532723256 022663 0 ustar steve steve
Overview
This package creates the MDR file.
There are many, many possible sections in the file. We will attempt
to find the minimum number required to make something work.
Sections to be implemented first
Use a header of size 286.
This gives us the possibility of the first 19 sections.
Initial sections to implement: 1, 4, 5, 6, 7, 11, 15.
Of these 4 is not known and only some subsection of MDR 1 are
also not known.
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr9.java 0000644 0000764 0000764 00000003562 11642347335 022067 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.LinkedHashMap;
import java.util.Map;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* An index into mdr10. There is a single byte group number followed by
* the first record in mdr10 that belongs to that group.
*
* @author Steve Ratcliffe
*/
public class Mdr9 extends MdrSection implements HasHeaderFlags {
private final Map index = new LinkedHashMap();
public Mdr9(MdrConfig config) {
setConfig(config);
}
public void writeSectData(ImgFileWriter writer) {
int poiSize = getSizes().getPoiSize();
for (Map.Entry ent : index.entrySet()) {
int group = ent.getKey();
writer.put((byte) group);
putN(writer, poiSize, ent.getValue());
}
}
/**
* The item size is one byte for the group and then enough bytes for the
* index into mdr10.
* @return Just return 4 for now.
*/
public int getItemSize() {
return 1 + getSizes().getPoiSize();
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return index.size();
}
public void setGroups(Map groupSizes) {
int offset = 1;
for (Map.Entry ent : groupSizes.entrySet()) {
index.put(ent.getKey(), offset);
offset += ent.getValue();
}
}
public int getExtraValue() {
return 0x00;
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr2x.java 0000644 0000764 0000764 00000006653 12467220204 022243 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Common code for 20, 21, 22 which are all lists of streets ordered in
* different ways.
*
* @author Steve Ratcliffe
*/
public abstract class Mdr2x extends MdrMapSection implements HasHeaderFlags {
protected List streets = new ArrayList<>();
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
String lastName = null;
Mdr7Record prev = null;
int size = getSizes().getStreetSizeFlagged();
boolean hasLabel = hasFlag(0x2);
String lastPartial = null;
int recordNumber = 0;
for (Mdr7Record street : streets) {
assert street.getMapIndex() == street.getCity().getMapIndex() : street.getMapIndex() + "/" + street.getCity().getMapIndex();
addIndexPointer(street.getMapIndex(), ++recordNumber);
int index = street.getIndex();
String name = street.getName();
int repeat = 1;
if (name.equals(lastName) && sameGroup(street, prev))
repeat = 0;
if (hasLabel) {
putMapIndex(writer, street.getMapIndex());
int offset = street.getLabelOffset();
if (repeat != 0)
offset |= 0x800000;
int trailing = 0;
String partialName = street.getPartialName();
if (!partialName.equals(lastPartial)) {
trailing |= 1;
offset |= 0x800000;
}
writer.put3(offset);
writer.put(street.getOutNameOffset());
writer.put((byte) trailing);
lastPartial = partialName;
} else
putN(writer, size, (index << 1) | repeat);
lastName = name;
prev = street;
}
}
/**
* The size of a record in the section.
*
* For these sections there is one field that is an index into the
* streets with an extra bit for a flag.
*
* In the device configuration, then there is a label and a flag, just like
* for mdr7.
*/
public int getItemSize() {
int size;
if (isForDevice()) {
// map-index, label, name-offset, 1byte flag
size = getSizes().getMapSize() + 3 + 1 + 1;
} else {
size = getSizes().getStreetSizeFlagged();
}
return size;
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return streets.size();
}
protected void releaseMemory() {
streets = null;
}
/**
* These sections are divided into groups based on city, region or country. This routine is
* implemented to return true if the two streets are in the same group.
*
* It is not clear if this is needed for region or country.
* @param street1 The first street.
* @param street2 The street to compare against.
* @return True if the streets are in the same group (city, region etc).
*/
protected abstract boolean sameGroup(Mdr7Record street1, Mdr7Record street2);
public void relabelMaps(Mdr1 maps) {
// Nothing to do, since all streets are re-labeled in their own section.
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr24.java 0000644 0000764 0000764 00000005317 11642347335 022144 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* Countries sorted by name. Same number of entries as 14.
*
* @author Steve Ratcliffe
*/
public class Mdr24 extends MdrSection {
private final List countries = new ArrayList();
public Mdr24(MdrConfig config) {
setConfig(config);
}
/**
* Sort the countries by name. Duplicates are kept.
* @param list The full list of countries.
*/
public void sortCountries(List list) {
Sort sort = getConfig().getSort();
List> keys = MdrUtils.sortList(sort, list);
Collections.sort(keys);
String lastName = null;
int lastMapIndex = 0;
int record = 0;
for (SortKey key : keys) {
Mdr14Record c = key.getObject();
// If this is a new name, then we prepare a mdr29 record for it.
String name = c.getName();
if (lastMapIndex != c.getMapIndex() || !name.equals(lastName)) {
record++;
c.getMdr29().setMdr24(record);
countries.add(c);
lastName = name;
lastMapIndex = c.getMapIndex();
}
}
}
/**
* Write out the contents of this section.
*
* @param writer Where to write it.
*/
public void writeSectData(ImgFileWriter writer) {
String lastName = null;
for (Mdr14Record c : countries) {
putMapIndex(writer, c.getMapIndex());
int flag = 0;
String name = c.getName();
if (!name.equals(lastName)) {
flag = 0x800000;
lastName = name;
}
writer.putChar((char) c.getCountryIndex());
writer.put3(c.getLblOffset() | flag);
}
}
/**
* The size of a record in the section. This is not a constant and might vary
* on various factors, such as the file version, if we are preparing for a
* device, the number of maps etc.
*
* @return The size of a record in this section.
*/
public int getItemSize() {
PointerSizes sizes = getSizes();
return sizes.getMapSize() + 2 + 3;
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return countries.size();
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr1.java 0000644 0000764 0000764 00000010711 12325011461 022034 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* The section MDR 1 contains a list of maps and for each map
* an offset to a reverse index for that map.
*
* The reverse index consists of a number of sections, that I call sub-sections
* here. The sub-sections are all lists of record numbers in other sections
* in the MDR that contain records belonging to more than one map.
*
* Using the index you could extract records that belong to an individual map
* from other MDR sections without having to go through them all and check
* which map they belong to.
*
* The subsections are as follows:
*
* sub1 points into MDR 11 (POIs)
* sub2 points into MDR 10 (POI types)
* sub3 points into MDR 7 (street names)
* sub4 points into MDR 5 (cities)
* sub5 points into MDR 6 (zips)
* sub6 points into MDR 20
* sub7 points into MDR 21
* sub8 points into MDR 22
*
* @author Steve Ratcliffe
*/
public class Mdr1 extends MdrSection implements HasHeaderFlags {
private final List maps = new ArrayList<>();
private int[] mapping;
public Mdr1(MdrConfig config) {
setConfig(config);
}
/**
* Add a map. Create an MDR1 record for it and also allocate its reverse
* index if this is not for a device.
* @param mapNumber The map index number.
* @param index The map index.
*/
public void addMap(int mapNumber, int index) {
assert index > 0;
Mdr1Record rec = new Mdr1Record(mapNumber, getConfig());
rec.setMapIndex(index);
maps.add(rec);
if (!isForDevice()) {
Mdr1MapIndex mapIndex = new Mdr1MapIndex();
rec.setMdrMapIndex(mapIndex);
}
}
/**
* The maps must be sorted in numerical order.
*/
public void finish() {
Collections.sort(maps, new Comparator() {
public int compare(Mdr1Record o1, Mdr1Record o2) {
if (o1.getMapNumber() == o2.getMapNumber())
return 0;
else if (o1.getMapNumber() < o2.getMapNumber())
return -1;
else
return 1;
}
});
// Used to renumber all the existing (pre-sorted) map index numbers.
mapping = new int[maps.size()];
int count = 1;
for (Mdr1Record r : maps) {
mapping[r.getMapIndex()-1] = count;
count++;
}
}
public void writeSubSections(ImgFileWriter writer) {
if (isForDevice())
return;
for (Mdr1Record rec : maps) {
rec.setIndexOffset(writer.position());
Mdr1MapIndex mapIndex = rec.getMdrMapIndex();
mapIndex.writeSubSection(writer);
}
}
/**
* This is written right at the end after we know all the offsets in
* the MDR 1 record.
* @param writer The mdr 1 records are written out to this writer.
*/
public void writeSectData(ImgFileWriter writer) {
boolean revIndex = (getExtraValue() & 1) != 0;
for (Mdr1Record rec : maps) {
writer.putInt(rec.getMapNumber());
if (revIndex)
writer.putInt(rec.getIndexOffset());
}
}
public int getItemSize() {
return isForDevice()? 4: 8;
}
public void setStartPosition(int sectionNumber) {
if (isForDevice())
return;
for (Mdr1Record mi : maps)
mi.getMdrMapIndex().startSection(sectionNumber);
}
public void setEndPosition(int sectionNumber) {
if (isForDevice())
return;
for (Mdr1Record mi : maps) {
mi.getMdrMapIndex().endSection(sectionNumber);
}
}
public void setPointerSize(int sectionSize, int recordSize) {
for (Mdr1Record mi : maps) {
Mdr1MapIndex mapIndex = mi.getMdrMapIndex();
mapIndex.setPointerSize(sectionSize, recordSize);
}
}
public void addPointer(int mapNumber, int recordNumber) {
Mdr1MapIndex mi = maps.get(mapNumber - 1).getMdrMapIndex();
mi.addPointer(recordNumber);
}
/**
* The number of records in this section.
*
* @return The number of items in the section.
*/
protected int numberOfItems() {
return maps.size();
}
public int getExtraValue() {
int magic = 0;
if (!isForDevice())
magic |= 1;
return magic;
}
public int sortedMapIndex(int n) {
return mapping[n-1];
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr6.java 0000644 0000764 0000764 00000004676 12325011461 022056 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.lbl.Zip;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* Section containing zip codes.
*
* We need: map number, zip index in map, pointer into MDR 15 for the string name.
*
* @author WanMil
*/
public class Mdr6 extends MdrMapSection {
private final List zips = new ArrayList<>();
public Mdr6(MdrConfig config) {
setConfig(config);
}
public void addZip(int mapIndex, Zip zip, int strOff) {
Mdr6Record record = new Mdr6Record(zip);
record.setMapIndex(mapIndex);
record.setStringOffset(strOff);
zips.add(record);
}
public void writeSectData(ImgFileWriter writer) {
int zipSize = getSizes().getZipSize();
List> sortKeys = MdrUtils.sortList(getConfig().getSort(), zips);
boolean hasString = hasFlag(0x4);
int record = 1;
for (SortKey key : sortKeys) {
Mdr6Record z = key.getObject();
addIndexPointer(z.getMapIndex(), record++);
putMapIndex(writer, z.getMapIndex());
putN(writer, zipSize, z.getZipIndex());
if (hasString)
putStringOffset(writer, z.getStringOffset());
}
}
/**
* Enough bytes to represent the map number
* and the zip index and the string offset.
* @return The size of a record in this section.
*/
public int getItemSize() {
PointerSizes sizes = getSizes();
int size = sizes.getMapSize() + sizes.getZipSize();
if (hasFlag(0x4))
size += sizes.getStrOffSize();
return size;
}
protected int numberOfItems() {
return zips.size();
}
/**
* Known structure:
* bits 0-1: size of local zip index - 1 (all values appear to work)
* bits 2: if MDR 15 available
* @return The value to be placed in the header.
*/
public int getExtraValue() {
return ((getSizes().getZipSize()-1)&0x03) | (isForDevice() ? 0 : 0x04);
}
public void relabelMaps(Mdr1 maps) {
relabel(maps, zips);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr7Record.java 0000644 0000764 0000764 00000005567 12476306743 023237 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
/**
* Holds details of a single street.
* @author Steve Ratcliffe
*/
public class Mdr7Record extends RecordBase implements NamedRecord {
private int labelOffset;
private int stringOffset;
private String name;
private int index;
private Mdr5Record city;
// For searching on partial names
private byte nameOffset; // offset into the name where matching should start
private byte outNameOffset; // offset into the encoded output name
private byte prefixOffset; // offset after 0x1e prefix
private byte suffixOffset; // offset just before 0x1f suffix
public int getLabelOffset() {
return labelOffset;
}
public void setLabelOffset(int labelOffset) {
this.labelOffset = labelOffset;
}
public int getStringOffset() {
return stringOffset;
}
public void setStringOffset(int stringOffset) {
this.stringOffset = stringOffset;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setIndex(int index) {
this.index = index;
}
public int getIndex() {
return index;
}
public void setCity(Mdr5Record city) {
this.city = city;
}
public Mdr5Record getCity() {
return city;
}
public int getNameOffset() {
return nameOffset & 0xff;
}
public void setNameOffset(byte nameOffset) {
this.nameOffset = nameOffset;
}
public byte getOutNameOffset() {
return outNameOffset;
}
public void setOutNameOffset(byte outNameOffset) {
this.outNameOffset = outNameOffset;
}
public void setPrefixOffset(byte prefixOffset) {
this.prefixOffset = prefixOffset;
}
public void setSuffixOffset(byte suffixOffset) {
this.suffixOffset = suffixOffset;
}
/**
* Get the name starting at the given nameOffset.
*
* To avoid creating unnecessary objects, a check is made for an offset of zero
* and the original name string is returned.
*
* @return A substring of name, starting at the nameOffset value.
*/
public String getPartialName() {
if (nameOffset == 0 && prefixOffset == 0 && suffixOffset == 0)
return name;
else if ((suffixOffset & 0xff) > 0)
return name.substring((nameOffset & 0xff) + (prefixOffset & 0xff), (suffixOffset & 0xff));
else
return name.substring((nameOffset & 0xff) + (prefixOffset & 0xff));
}
public String toString() {
return name + " in " + city.getName();
}
public String getInitialPart() {
return name.substring(0, (nameOffset & 0xff));
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr1MapIndex.java 0000644 0000764 0000764 00000004645 11532723256 023506 0 ustar steve steve /*
* Copyright (C) 2009.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.nio.ByteBuffer;
import uk.me.parabola.imgfmt.app.BufferedImgFileWriter;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
/**
* Each map has one of these and it is used to provide a list of records
* in the various sections that actually belong to this map.
*
* @author Steve Ratcliffe
*/
public class Mdr1MapIndex {
private final Mdr1SubHeader subHeader = new Mdr1SubHeader();
private final BufferedImgFileWriter subWriter = new BufferedImgFileWriter(null);
private int pointerSize;
public Mdr1MapIndex() {
// skip over where the header will be
this.subWriter.position(subHeader.getHeaderLen());
}
public void startSection(int n) {
}
public void endSection(int n) {
int sn = sectionToSubsection(n);
if (sn != 0)
subHeader.setEndSubsection(sn, subWriter.position());
}
public void addPointer(int recordNumber) {
switch (pointerSize) {
case 4:
subWriter.putInt(recordNumber);
break;
case 3:
subWriter.put3(recordNumber);
break;
case 2:
subWriter.putChar((char) recordNumber);
break;
case 1:
subWriter.put((byte) recordNumber);
break;
default:
assert false;
}
}
private int sectionToSubsection(int n) {
int sn;
switch (n) {
case 11: sn = 1; break;
case 10: sn = 2; break;
case 7: sn = 3; break;
case 5: sn = 4; break;
case 6: sn = 5; break;
case 20: sn = 6; break;
case 21: sn = 7; break;
case 22: sn = 8; break;
default: sn = 0; break;
}
return sn;
}
public void writeSubSection(ImgFileWriter writer) {
subHeader.writeFileHeader(writer);
ByteBuffer buffer = subWriter.getBuffer();
byte[] bytes = buffer.array();
int hl = (int) subHeader.getHeaderLen();
writer.put(bytes, hl, buffer.position() - hl);
}
public void setPointerSize(int sectionNumber, int pointerSize) {
this.pointerSize = pointerSize;
int sn = sectionToSubsection(sectionNumber);
if (sn != 0)
subHeader.setItemSize(sn, pointerSize);
}
}
mkgmap-r3660/src/uk/me/parabola/imgfmt/app/mdr/Mdr25.java 0000644 0000764 0000764 00000005242 11701624112 022125 0 ustar steve steve /*
* Copyright (C) 2011.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 or
* version 2 as published by the Free Software Foundation.
*
* 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
* General Public License for more details.
*/
package uk.me.parabola.imgfmt.app.mdr;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.srt.Sort;
import uk.me.parabola.imgfmt.app.srt.SortKey;
/**
* Cities sorted by country.
*
* @author Steve Ratcliffe
*/
public class Mdr25 extends MdrSection {
private final List cities = new ArrayList();
public Mdr25(MdrConfig config) {
setConfig(config);
}
/**
* Cities are sorted by country and then by the mdr5 city record number.
* @param list The complete list of cities from mdr5.
*/
public void sortCities(List list) {
Sort sort = getConfig().getSort();
List> keys = new ArrayList>();
for (Mdr5Record c : list) {
SortKey