@@ -444,8 +444,8 @@ OBJS-$(CONFIG_TARGA_ENCODER)           += targaenc.o rle.o

 OBJS-$(CONFIG_THEORA_DECODER)          += xiph.o

 OBJS-$(CONFIG_THP_DECODER)             += mjpegdec.o mjpeg.o

 OBJS-$(CONFIG_TIERTEXSEQVIDEO_DECODER) += tiertexseqv.o

-OBJS-$(CONFIG_TIFF_DECODER)            += tiff.o lzw.o faxcompr.o

-OBJS-$(CONFIG_TIFF_ENCODER)            += tiffenc.o rle.o lzwenc.o

+OBJS-$(CONFIG_TIFF_DECODER)            += tiff.o lzw.o faxcompr.o tiff_data.o

+OBJS-$(CONFIG_TIFF_ENCODER)            += tiffenc.o rle.o lzwenc.o tiff_data.o

 OBJS-$(CONFIG_TMV_DECODER)             += tmv.o cga_data.o

 OBJS-$(CONFIG_TRUEHD_DECODER)          += mlpdec.o mlpdsp.o

 OBJS-$(CONFIG_TRUEMOTION1_DECODER)     += truemotion1.o

@@ -30,10 +30,12 @@

 #endif

 #include "lzw.h"

 #include "tiff.h"

+#include "tiff_data.h"

 #include "faxcompr.h"

 #include "libavutil/common.h"

 #include "libavutil/intreadwrite.h"

 #include "libavutil/imgutils.h"

+#include "libavutil/avstring.h"

 typedef struct TiffContext {

     AVCodecContext *avctx;

@@ -56,6 +58,9 @@ typedef struct TiffContext {

     const uint8_t *stripsizes;

     int stripsize, stripoff;

     LZWState *lzw;

+

+    int geotag_count;

+    TiffGeoTag *geotags;

 } TiffContext;

 static unsigned tget_short(const uint8_t **p, int le)

@@ -72,6 +77,13 @@ static unsigned tget_long(const uint8_t **p, int le)

     return v;

 }

+static double tget_double(const uint8_t **p, int le)

+{

+    av_alias64 i = { .u64 = le ? AV_RL64(*p) : AV_RB64(*p)};

+    *p += 8;

+    return i.f64;

+}

+

 static unsigned tget(const uint8_t **p, int type, int le)

 {

     switch (type) {

@@ -82,6 +94,202 @@ static unsigned tget(const uint8_t **p, int type, int le)

     }

 }

+static void free_geotags(TiffContext *const s)

+{

+    int i;

+    for (i = 0; i < s->geotag_count; i++) {

+        if (s->geotags[i].val)

+            av_freep(&s->geotags[i].val);

+    }

+    av_freep(&s->geotags);

+}

+

+#define RET_GEOKEY(TYPE, array, element)\

+    if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\

+        key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_name_type_map))\

+        return ff_tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].element;

+

+static const char *get_geokey_name(int key)

+{

+    RET_GEOKEY(VERT, vert, name);

+    RET_GEOKEY(PROJ, proj, name);

+    RET_GEOKEY(GEOG, geog, name);

+    RET_GEOKEY(CONF, conf, name);

+

+    return NULL;

+}

+

+static int get_geokey_type(int key)

+{

+    RET_GEOKEY(VERT, vert, type);

+    RET_GEOKEY(PROJ, proj, type);

+    RET_GEOKEY(GEOG, geog, type);

+    RET_GEOKEY(CONF, conf, type);

+

+    return AVERROR_INVALIDDATA;

+}

+

+static int cmp_id_key(const void *id, const void *k)

+{

+    return *(const int*)id - ((const TiffGeoTagKeyName*)k)->key;

+}

+

+static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id)

+{

+    return ((TiffGeoTagKeyName*)bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key))->name;

+}

+

+static char *get_geokey_val(int key, int val)

+{

+    char *ap;

+

+    if (val == TIFF_GEO_KEY_UNDEFINED)

+        return av_strdup("undefined");

+    if (val == TIFF_GEO_KEY_USER_DEFINED)

+        return av_strdup("User-Defined");

+

+#define RET_GEOKEY_VAL(TYPE, array)\

+    if (val >= TIFF_##TYPE##_OFFSET &&\

+        val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_codes))\

+        return av_strdup(ff_tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET]);

+

+    switch (key) {

+    case TIFF_GT_MODEL_TYPE_GEOKEY:

+        RET_GEOKEY_VAL(GT_MODEL_TYPE, gt_model_type);

+        break;

+    case TIFF_GT_RASTER_TYPE_GEOKEY:

+        RET_GEOKEY_VAL(GT_RASTER_TYPE, gt_raster_type);

+        break;

+    case TIFF_GEOG_LINEAR_UNITS_GEOKEY:

+    case TIFF_PROJ_LINEAR_UNITS_GEOKEY:

+    case TIFF_VERTICAL_UNITS_GEOKEY:

+        RET_GEOKEY_VAL(LINEAR_UNIT, linear_unit);

+        break;

+    case TIFF_GEOG_ANGULAR_UNITS_GEOKEY:

+    case TIFF_GEOG_AZIMUTH_UNITS_GEOKEY:

+        RET_GEOKEY_VAL(ANGULAR_UNIT, angular_unit);

+        break;

+    case TIFF_GEOGRAPHIC_TYPE_GEOKEY:

+        RET_GEOKEY_VAL(GCS_TYPE, gcs_type);

+        RET_GEOKEY_VAL(GCSE_TYPE, gcse_type);

+        break;

+    case TIFF_GEOG_GEODETIC_DATUM_GEOKEY:

+        RET_GEOKEY_VAL(GEODETIC_DATUM, geodetic_datum);

+        RET_GEOKEY_VAL(GEODETIC_DATUM_E, geodetic_datum_e);

+        break;

+    case TIFF_GEOG_ELLIPSOID_GEOKEY:

+        RET_GEOKEY_VAL(ELLIPSOID, ellipsoid);

+        break;

+    case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY:

+        RET_GEOKEY_VAL(PRIME_MERIDIAN, prime_meridian);

+        break;

+    case TIFF_PROJECTED_CS_TYPE_GEOKEY:

+        return av_strdup(search_keyval(ff_tiff_proj_cs_type_codes, FF_ARRAY_ELEMS(ff_tiff_proj_cs_type_codes), val));

+        break;

+    case TIFF_PROJECTION_GEOKEY:

+        return av_strdup(search_keyval(ff_tiff_projection_codes, FF_ARRAY_ELEMS(ff_tiff_projection_codes), val));

+        break;

+    case TIFF_PROJ_COORD_TRANS_GEOKEY:

+        RET_GEOKEY_VAL(COORD_TRANS, coord_trans);

+        break;

+    case TIFF_VERTICAL_CS_TYPE_GEOKEY:

+        RET_GEOKEY_VAL(VERT_CS, vert_cs);

+        RET_GEOKEY_VAL(ORTHO_VERT_CS, ortho_vert_cs);

+        break;

+

+    }

+

+    ap = av_malloc(14);

+    if (ap)

+        snprintf(ap, 14, "Unknown-%d", val);

+    return ap;

+}

+

+static char *doubles2str(double *dp, int count, const char *sep)

+{

+    int i;

+    char *ap, *ap0;

+    if (!sep) sep = ", ";

+    ap = av_malloc((15 + strlen(sep)) * count);

+    if (!ap)

+        return NULL;

+    ap0   = ap;

+    ap[0] = '\0';

+    for (i = 0; i < count; i++) {

+        int l = snprintf(ap, 15 + strlen(sep), "%f%s", dp[i], sep);

+        ap += l;

+    }

+    ap0[strlen(ap0) - strlen(sep)] = '\0';

+    return ap0;

+}

+

+static char *shorts2str(int *sp, int count, const char *sep)

+{

+    int i;

+    char *ap, *ap0;

+    if (!sep) sep = ", ";

+    ap = av_malloc((5 + strlen(sep)) * count);

+    if (!ap)

+        return NULL;

+    ap0   = ap;

+    ap[0] = '\0';

+    for (i = 0; i < count; i++) {

+        int l = snprintf(ap, 5 + strlen(sep), "%d%s", sp[i], sep);

+        ap += l;

+    }

+    ap0[strlen(ap0) - strlen(sep)] = '\0';

+    return ap0;

+}

+

+static int add_doubles_metadata(const uint8_t **buf, int count,

+                                const char *name, const char *sep,

+                                TiffContext *s)

+{

+    char *ap;

+    int i;

+    double *dp = av_malloc(count * sizeof(double));

+    if (!dp)

+        return AVERROR(ENOMEM);

+

+    for (i = 0; i < count; i++)

+        dp[i] = tget_double(buf, s->le);

+    ap = doubles2str(dp, count, sep);

+    av_freep(&dp);

+    if (!ap)

+        return AVERROR(ENOMEM);

+    av_dict_set(&s->picture.metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);

+    return 0;

+}

+

+static int add_shorts_metadata(const uint8_t **buf, int count, const char *name,

+                               const char *sep, TiffContext *s)

+{

+    char *ap;

+    int i;

+    int *sp = av_malloc(count * sizeof(int));

+    if (!sp)

+        return AVERROR(ENOMEM);

+

+    for (i = 0; i < count; i++)

+        sp[i] = tget_short(buf, s->le);

+    ap = shorts2str(sp, count, sep);

+    av_freep(&sp);

+    if (!ap)

+        return AVERROR(ENOMEM);

+    av_dict_set(&s->picture.metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);

+    return 0;

+}

+

+static int add_metadata(const uint8_t **buf, int count, int type,

+                        const char *name, const char *sep, TiffContext *s)

+{

+    switch(type) {

+    case TIFF_DOUBLE: return add_doubles_metadata(buf, count, name, sep, s);

+    case TIFF_SHORT : return add_shorts_metadata(buf, count, name, sep, s);

+    default         : return AVERROR_INVALIDDATA;

+    };

+}

+

 #if CONFIG_ZLIB

 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,

                            int size)

@@ -372,8 +580,10 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,

 {

     unsigned tag, type, count, off, value = 0;

     int i, j;

+    int ret;

     uint32_t *pal;

     const uint8_t *rp, *gp, *bp;

+    double *dp;

     if (end_buf - buf < 12)

         return -1;

@@ -608,6 +818,89 @@ static int tiff_decode_tag(TiffContext *s, const uint8_t *start,

         if (s->compr == TIFF_G4)

             s->fax_opts = value;

         break;

+#define ADD_METADATA(count, name, sep)\

+    if (ret = add_metadata(&buf, count, type, name, sep, s) < 0) {\

+        av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\

+        return ret;\

+    }

+    case TIFF_MODEL_PIXEL_SCALE:

+        ADD_METADATA(count, "ModelPixelScaleTag", NULL);

+        break;

+    case TIFF_MODEL_TRANSFORMATION:

+        ADD_METADATA(count, "ModelTransformationTag", NULL);

+        break;

+    case TIFF_MODEL_TIEPOINT:

+        ADD_METADATA(count, "ModelTiepointTag", NULL);

+        break;

+    case TIFF_GEO_KEY_DIRECTORY:

+        ADD_METADATA(1, "GeoTIFF_Version", NULL);

+        ADD_METADATA(2, "GeoTIFF_Key_Revision", ".");

+        s->geotag_count   = tget_short(&buf, s->le);

+        if (s->geotag_count > count / 4 - 1) {

+            s->geotag_count = count / 4 - 1;

+            av_log(s->avctx, AV_LOG_WARNING, "GeoTIFF key directory buffer shorter than specified\n");

+        }

+        s->geotags = av_mallocz(sizeof(TiffGeoTag) * s->geotag_count);

+        if (!s->geotags) {

+            av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");

+            return AVERROR(ENOMEM);

+        }

+        for (i = 0; i < s->geotag_count; i++) {

+            s->geotags[i].key    = tget_short(&buf, s->le);

+            s->geotags[i].type   = tget_short(&buf, s->le);

+            s->geotags[i].count  = tget_short(&buf, s->le);

+

+            if (!s->geotags[i].type)

+                s->geotags[i].val  = get_geokey_val(s->geotags[i].key, tget_short(&buf, s->le));

+            else

+                s->geotags[i].offset = tget_short(&buf, s->le);

+        }

+        break;

+    case TIFF_GEO_DOUBLE_PARAMS:

+        dp = av_malloc(count * sizeof(double));

+        if (!dp) {

+            av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");

+            return AVERROR(ENOMEM);

+        }

+        for (i = 0; i < count; i++)

+            dp[i] = tget_double(&buf, s->le);

+        for (i = 0; i < s->geotag_count; i++) {

+            if (s->geotags[i].type == TIFF_GEO_DOUBLE_PARAMS) {

+                if (s->geotags[i].count == 0

+                    || s->geotags[i].offset + s->geotags[i].count > count) {

+                    av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key);

+                } else {

+                    char *ap = doubles2str(&dp[s->geotags[i].offset], s->geotags[i].count, ", ");

+                    if (!ap) {

+                        av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");

+                        av_freep(&dp);

+                        return AVERROR(ENOMEM);

+                    }

+                    s->geotags[i].val = ap;

+                }

+            }

+        }

+        av_freep(&dp);

+        break;

+    case TIFF_GEO_ASCII_PARAMS:

+        for (i = 0; i < s->geotag_count; i++) {

+            if (s->geotags[i].type == TIFF_GEO_ASCII_PARAMS) {

+                if (s->geotags[i].count == 0

+                    || s->geotags[i].offset +  s->geotags[i].count > count) {

+                    av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key);

+                } else {

+                    char *ap = av_malloc(s->geotags[i].count);

+                    if (!ap) {

+                        av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");

+                        return AVERROR(ENOMEM);

+                    }

+                    memcpy(ap, &buf[s->geotags[i].offset], s->geotags[i].count);

+                    ap[s->geotags[i].count - 1] = '\0'; //replace the "|" delimiter with a 0 byte

+                    s->geotags[i].val = ap;

+                }

+            }

+        }

+        break;

     default:

         av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n",

                tag, tag);

@@ -648,6 +941,10 @@ static int decode_frame(AVCodecContext *avctx,

     s->invert = 0;

     s->compr = TIFF_RAW;

     s->fill_order = 0;

+    free_geotags(s);

+    /* free existing metadata */

+    av_dict_free(&s->picture.metadata);

+

     // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number

     // that further identifies the file as a TIFF file"

     if (tget_short(&buf, le) != 42) {

@@ -670,6 +967,24 @@ static int decode_frame(AVCodecContext *avctx,

             return -1;

         buf += 12;

     }

+

+    for (i = 0; i<s->geotag_count; i++) {

+        const char *keyname = get_geokey_name(s->geotags[i].key);

+        if (!keyname) {

+            av_log(avctx, AV_LOG_WARNING, "Unknown or unsupported GeoTIFF key %d\n", s->geotags[i].key);

+            continue;

+        }

+        if (get_geokey_type(s->geotags[i].key) != s->geotags[i].type) {

+            av_log(avctx, AV_LOG_WARNING, "Type of GeoTIFF key %d is wrong\n", s->geotags[i].key);

+            continue;

+        }

+        ret = av_dict_set(&s->picture.metadata, keyname, s->geotags[i].val, 0);

+        if (ret<0) {

+            av_log(avctx, AV_LOG_ERROR, "Writing metadata with key '%s' failed\n", keyname);

+            return ret;

+        }

+    }

+

     if (!s->stripdata && !s->stripoff) {

         av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");

         return -1;

@@ -768,6 +1083,10 @@ static av_cold int tiff_end(AVCodecContext *avctx)

 {

     TiffContext *const s = avctx->priv_data;

+    free_geotags(s);

+    if (avctx->coded_frame && avctx->coded_frame->metadata)

+        av_dict_free(&avctx->coded_frame->metadata);

+

     ff_lzw_decode_close(&s->lzw);

     if (s->picture.data[0])

         avctx->release_buffer(avctx, &s->picture);

@@ -64,6 +64,12 @@ enum TiffTags{

     TIFF_YCBCR_SUBSAMPLING = 0x212,

     TIFF_YCBCR_POSITIONING = 0x213,

     TIFF_REFERENCE_BW = 0x214,

+    TIFF_MODEL_TIEPOINT = 0x8482,

+    TIFF_MODEL_PIXEL_SCALE = 0x830E,

+    TIFF_MODEL_TRANSFORMATION = 0x8480,

+    TIFF_GEO_KEY_DIRECTORY = 0x87AF,

+    TIFF_GEO_DOUBLE_PARAMS = 0x87B0,

+    TIFF_GEO_ASCII_PARAMS = 0x87B1

 };

 /** list of TIFF compression types */

@@ -86,11 +92,91 @@ enum TiffTypes{

     TIFF_SHORT,

     TIFF_LONG,

     TIFF_RATIONAL,

+    TIFF_SBYTE,

+    TIFF_UNDEFINED,

+    TIFF_SSHORT,

+    TIFF_SLONG,

+    TIFF_SRATIONAL,

+    TIFF_FLOAT,

+    TIFF_DOUBLE,

+    TIFF_IFD

+};

+

+enum TiffGeoTagKey {

+    TIFF_GT_MODEL_TYPE_GEOKEY                = 1024,

+    TIFF_GT_RASTER_TYPE_GEOKEY               = 1025,

+    TIFF_GT_CITATION_GEOKEY                  = 1026,

+    TIFF_GEOGRAPHIC_TYPE_GEOKEY              = 2048,

+    TIFF_GEOG_CITATION_GEOKEY                = 2049,

+    TIFF_GEOG_GEODETIC_DATUM_GEOKEY          = 2050,

+    TIFF_GEOG_PRIME_MERIDIAN_GEOKEY          = 2051,

+    TIFF_GEOG_LINEAR_UNITS_GEOKEY            = 2052,

+    TIFF_GEOG_LINEAR_UNIT_SIZE_GEOKEY        = 2053,

+    TIFF_GEOG_ANGULAR_UNITS_GEOKEY           = 2054,

+    TIFF_GEOG_ANGULAR_UNIT_SIZE_GEOKEY       = 2055,

+    TIFF_GEOG_ELLIPSOID_GEOKEY               = 2056,

+    TIFF_GEOG_SEMI_MAJOR_AXIS_GEOKEY         = 2057,

+    TIFF_GEOG_SEMI_MINOR_AXIS_GEOKEY         = 2058,

+    TIFF_GEOG_INV_FLATTENING_GEOKEY          = 2059,

+    TIFF_GEOG_AZIMUTH_UNITS_GEOKEY           = 2060,

+    TIFF_GEOG_PRIME_MERIDIAN_LONG_GEOKEY     = 2061,

+    TIFF_PROJECTED_CS_TYPE_GEOKEY            = 3072,

+    TIFF_PCS_CITATION_GEOKEY                 = 3073,

+    TIFF_PROJECTION_GEOKEY                   = 3074,

+    TIFF_PROJ_COORD_TRANS_GEOKEY             = 3075,

+    TIFF_PROJ_LINEAR_UNITS_GEOKEY            = 3076,

+    TIFF_PROJ_LINEAR_UNIT_SIZE_GEOKEY        = 3077,

+    TIFF_PROJ_STD_PARALLEL1_GEOKEY           = 3078,

+    TIFF_PROJ_STD_PARALLEL2_GEOKEY           = 3079,

+    TIFF_PROJ_NAT_ORIGIN_LONG_GEOKEY         = 3080,

+    TIFF_PROJ_NAT_ORIGIN_LAT_GEOKEY          = 3081,

+    TIFF_PROJ_FALSE_EASTING_GEOKEY           = 3082,

+    TIFF_PROJ_FALSE_NORTHING_GEOKEY          = 3083,

+    TIFF_PROJ_FALSE_ORIGIN_LONG_GEOKEY       = 3084,

+    TIFF_PROJ_FALSE_ORIGIN_LAT_GEOKEY        = 3085,

+    TIFF_PROJ_FALSE_ORIGIN_EASTING_GEOKEY    = 3086,

+    TIFF_PROJ_FALSE_ORIGIN_NORTHING_GEOKEY   = 3087,

+    TIFF_PROJ_CENTER_LONG_GEOKEY             = 3088,

+    TIFF_PROJ_CENTER_LAT_GEOKEY              = 3089,

+    TIFF_PROJ_CENTER_EASTING_GEOKEY          = 3090,

+    TIFF_PROJ_CENTER_NORTHING_GEOKEY         = 3091,

+    TIFF_PROJ_SCALE_AT_NAT_ORIGIN_GEOKEY     = 3092,

+    TIFF_PROJ_SCALE_AT_CENTER_GEOKEY         = 3093,

+    TIFF_PROJ_AZIMUTH_ANGLE_GEOKEY           = 3094,

+    TIFF_PROJ_STRAIGHT_VERT_POLE_LONG_GEOKEY = 3095,

+    TIFF_VERTICAL_CS_TYPE_GEOKEY             = 4096,

+    TIFF_VERTICAL_CITATION_GEOKEY            = 4097,

+    TIFF_VERTICAL_DATUM_GEOKEY               = 4098,

+    TIFF_VERTICAL_UNITS_GEOKEY               = 4099

+};

+

+enum TiffGeoTagType {

+    GEOTIFF_SHORT  = 0,

+    GEOTIFF_DOUBLE = 34736,

+    GEOTIFF_STRING = 34737

 };

 /** sizes of various TIFF field types (string size = 100)*/

-static const uint8_t type_sizes[6] = {

-    0, 1, 100, 2, 4, 8

+static const uint8_t type_sizes[14] = {

+    0, 1, 100, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4

 };

+typedef struct TiffGeoTag {

+    enum TiffGeoTagKey key;

+    enum TiffTags type;

+    int count;

+    int offset;

+    char *val;

+} TiffGeoTag;

+

+typedef struct TiffGeoTagKeyName {

+    const enum TiffGeoTagKey key;

+    const char *const name;

+} TiffGeoTagKeyName;

+

+typedef struct TiffGeoTagNameType {

+    const char *const name;

+    const enum TiffGeoTagType type;

+} TiffGeoTagNameType;

+

 #endif /* AVCODEC_TIFF_H */

new file mode 100644

@@ -0,0 +1,1870 @@

+/*

+ * TIFF data tables

+ * Copyright (c) 2011 Thomas Kuehnel

+ *

+ * This file is part of Libav.

+ *

+ * Libav is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * Libav is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file

+ * TIFF data tables

+ * @author Thomas Kuehnel

+ * @see GeoTIFF specification at

+ * http://www.remotesensing.org/geotiff/spec/geotiffhome.html

+ */

+

+#include "tiff_data.h"

+

+const TiffGeoTagNameType ff_tiff_conf_name_type_map[] = {

+    {"GTModelTypeGeoKey",              GEOTIFF_SHORT },

+    {"GTRasterTypeGeoKey",             GEOTIFF_SHORT },

+    {"GTCitationGeoKey",               GEOTIFF_STRING}

+};

+

+const TiffGeoTagNameType ff_tiff_geog_name_type_map[] = {

+    {"GeographicTypeGeoKey",           GEOTIFF_SHORT },

+    {"GeogCitationGeoKey",             GEOTIFF_STRING},

+    {"GeogGeodeticDatumGeoKey",        GEOTIFF_SHORT },

+    {"GeogPrimeMeridianGeoKey",        GEOTIFF_SHORT },

+    {"GeogLinearUnitsGeoKey",          GEOTIFF_SHORT },

+    {"GeogLinearUnitSizeGeoKey",       GEOTIFF_DOUBLE},

+    {"GeogAngularUnitsGeoKey",         GEOTIFF_SHORT },

+    {"GeogAngularUnitSizeGeoKey",      GEOTIFF_DOUBLE},

+    {"GeogEllipsoidGeoKey",            GEOTIFF_SHORT },

+    {"GeogSemiMajorAxisGeoKey",        GEOTIFF_DOUBLE},

+    {"GeogSemiMinorAxisGeoKey",        GEOTIFF_DOUBLE},

+    {"GeogInvFlatteningGeoKey",        GEOTIFF_DOUBLE},

+    {"GeogAzimuthUnitsGeoKey",         GEOTIFF_SHORT },

+    {"GeogPrimeMeridianLongGeoKey",    GEOTIFF_DOUBLE}

+};

+

+const TiffGeoTagNameType ff_tiff_proj_name_type_map[] = {

+    {"ProjectedCSTypeGeoKey",          GEOTIFF_SHORT },

+    {"PCSCitationGeoKey",              GEOTIFF_STRING},

+    {"ProjectionGeoKey",               GEOTIFF_SHORT },

+    {"ProjCoordTransGeoKey",           GEOTIFF_SHORT },

+    {"ProjLinearUnitsGeoKey",          GEOTIFF_SHORT },

+    {"ProjLinearUnitSizeGeoKey",       GEOTIFF_DOUBLE},

+    {"ProjStdParallel1GeoKey",         GEOTIFF_DOUBLE},

+    {"ProjStdParallel2GeoKey",         GEOTIFF_DOUBLE},

+    {"ProjNatOriginLongGeoKey",        GEOTIFF_DOUBLE},

+    {"ProjNatOriginLatGeoKey",         GEOTIFF_DOUBLE},

+    {"ProjFalseEastingGeoKey",         GEOTIFF_DOUBLE},

+    {"ProjFalseNorthingGeoKey",        GEOTIFF_DOUBLE},

+    {"ProjFalseOriginLongGeoKey",      GEOTIFF_DOUBLE},

+    {"ProjFalseOriginLatGeoKey",       GEOTIFF_DOUBLE},

+    {"ProjFalseOriginEastingGeoKey",   GEOTIFF_DOUBLE},

+    {"ProjFalseOriginNorthingGeoKey",  GEOTIFF_DOUBLE},

+    {"ProjCenterLongGeoKey",           GEOTIFF_DOUBLE},

+    {"ProjCenterLatGeoKey",            GEOTIFF_DOUBLE},

+    {"ProjCenterEastingGeoKey",        GEOTIFF_DOUBLE},

+    {"ProjCenterNorthingGeoKey",       GEOTIFF_DOUBLE},

+    {"ProjScaleAtNatOriginGeoKey",     GEOTIFF_DOUBLE},

+    {"ProjScaleAtCenterGeoKey",        GEOTIFF_DOUBLE},

+    {"ProjAzimuthAngleGeoKey",         GEOTIFF_DOUBLE},

+    {"ProjStraightVertPoleLongGeoKey", GEOTIFF_DOUBLE}

+};

+

+const TiffGeoTagNameType ff_tiff_vert_name_type_map[] = {

+    {"VerticalCSTypeGeoKey",           GEOTIFF_SHORT },

+    {"VerticalCitationGeoKey",         GEOTIFF_STRING},

+    {"VerticalDatumGeoKey",            GEOTIFF_SHORT },

+    {"VerticalUnitsGeoKey",            GEOTIFF_SHORT }

+};

+

+const char *const ff_tiff_gt_model_type_codes[] = {

+    "ModelTypeProjected",

+    "ModelTypeGeographic",

+    "ModelTypeGeocentric"

+};

+

+const char *const ff_tiff_gt_raster_type_codes[] = {

+    "RasterPixelIsArea",

+    "RasterPixelIsPoint"

+};

+

+const char *const ff_tiff_linear_unit_codes[] = {

+    "Linear_Meter",

+    "Linear_Foot",

+    "Linear_Foot_US_Survey",

+    "Linear_Foot_Modified_American",

+    "Linear_Foot_Clarke",

+    "Linear_Foot_Indian",

+    "Linear_Link",

+    "Linear_Link_Benoit",

+    "Linear_Link_Sears",

+    "Linear_Chain_Benoit",

+    "Linear_Chain_Sears",

+    "Linear_Yard_Sears",

+    "Linear_Yard_Indian",

+    "Linear_Fathom",

+    "Linear_Mile_International_Nautical"

+};

+

+const char *const ff_tiff_angular_unit_codes[] = {

+    "Angular_Radian",

+    "Angular_Degree",

+    "Angular_Arc_Minute",

+    "Angular_Arc_Second",

+    "Angular_Grad",

+    "Angular_Gon",

+    "Angular_DMS",

+    "Angular_DMS_Hemisphere"

+};

+

+const char *const ff_tiff_gcs_type_codes[] = {

+    "GCS_Adindan",

+    "GCS_AGD66",

+    "GCS_AGD84",

+    "GCS_Ain_el_Abd",

+    "GCS_Afgooye",

+    "GCS_Agadez",

+    "GCS_Lisbon",

+    "GCS_Aratu",

+    "GCS_Arc_1950",

+    "GCS_Arc_1960",

+    "GCS_Batavia",

+    "GCS_Barbados",

+    "GCS_Beduaram",

+    "GCS_Beijing_1954",

+    "GCS_Belge_1950",

+    "GCS_Bermuda_1957",

+    "GCS_Bern_1898",

+    "GCS_Bogota",

+    "GCS_Bukit_Rimpah",

+    "GCS_Camacupa",

+    "GCS_Campo_Inchauspe",

+    "GCS_Cape",

+    "GCS_Carthage",

+    "GCS_Chua",

+    "GCS_Corrego_Alegre",

+    "GCS_Cote_d_Ivoire",

+    "GCS_Deir_ez_Zor",

+    "GCS_Douala",

+    "GCS_Egypt_1907",

+    "GCS_ED50",

+    "GCS_ED87",

+    "GCS_Fahud",

+    "GCS_Gandajika_1970",

+    "GCS_Garoua",

+    "GCS_Guyane_Francaise",

+    "GCS_Hu_Tzu_Shan",

+    "GCS_HD72",

+    "GCS_ID74",

+    "GCS_Indian_1954",

+    "GCS_Indian_1975",

+    "GCS_Jamaica_1875",

+    "GCS_JAD69",

+    "GCS_Kalianpur",

+    "GCS_Kandawala",

+    "GCS_Kertau",

+    "GCS_KOC",

+    "GCS_La_Canoa",

+    "GCS_PSAD56",

+    "GCS_Lake",

+    "GCS_Leigon",

+    "GCS_Liberia_1964",

+    "GCS_Lome",

+    "GCS_Luzon_1911",

+    "GCS_Hito_XVIII_1963",

+    "GCS_Herat_North",

+    "GCS_Mahe_1971",

+    "GCS_Makassar",

+    "GCS_EUREF89",

+    "GCS_Malongo_1987",

+    "GCS_Manoca",

+    "GCS_Merchich",

+    "GCS_Massawa",

+    "GCS_Minna",

+    "GCS_Mhast",

+    "GCS_Monte_Mario",

+    "GCS_M_poraloko",

+    "GCS_NAD27",

+    "GCS_NAD_Michigan",

+    "GCS_NAD83",

+    "GCS_Nahrwan_1967",

+    "GCS_Naparima_1972",

+    "GCS_GD49",

+    "GCS_NGO_1948",

+    "GCS_Datum_73",

+    "GCS_NTF",

+    "GCS_NSWC_9Z_2",

+    "GCS_OSGB_1936",

+    "GCS_OSGB70",

+    "GCS_OS_SN80",

+    "GCS_Padang",

+    "GCS_Palestine_1923",

+    "GCS_Pointe_Noire",

+    "GCS_GDA94",

+    "GCS_Pulkovo_1942",

+    "GCS_Qatar",

+    "GCS_Qatar_1948",

+    "GCS_Qornoq",

+    "GCS_Loma_Quintana",

+    "GCS_Amersfoort",

+    "GCS_RT38",

+    "GCS_SAD69",

+    "GCS_Sapper_Hill_1943",

+    "GCS_Schwarzeck",

+    "GCS_Segora",

+    "GCS_Serindung",

+    "GCS_Sudan",

+    "GCS_Tananarive",

+    "GCS_Timbalai_1948",

+    "GCS_TM65",

+    "GCS_TM75",

+    "GCS_Tokyo",

+    "GCS_Trinidad_1903",

+    "GCS_TC_1948",

+    "GCS_Voirol_1875",

+    "GCS_Voirol_Unifie",

+    "GCS_Bern_1938",

+    "GCS_Nord_Sahara_1959",

+    "GCS_Stockholm_1938",

+    "GCS_Yacare",

+    "GCS_Yoff",

+    "GCS_Zanderij",

+    "GCS_MGI",

+    "GCS_Belge_1972",

+    "GCS_DHDN",

+    "GCS_Conakry_1905",

+    "GCS_WGS_72",

+    "GCS_WGS_72BE",

+    "GCS_WGS_84",

+    "GCS_Bern_1898_Bern",

+    "GCS_Bogota_Bogota",

+    "GCS_Lisbon_Lisbon",

+    "GCS_Makassar_Jakarta",

+    "GCS_MGI_Ferro",

+    "GCS_Monte_Mario_Rome",

+    "GCS_NTF_Paris",

+    "GCS_Padang_Jakarta",

+    "GCS_Belge_1950_Brussels",

+    "GCS_Tananarive_Paris",

+    "GCS_Voirol_1875_Paris",

+    "GCS_Voirol_Unifie_Paris",

+    "GCS_Batavia_Jakarta",

+    "GCS_ATF_Paris",

+    "GCS_NDG_Paris"

+};

+

+const char *const ff_tiff_gcse_type_codes[] = {

+    "GCSE_Airy1830",

+    "GCSE_AiryModified1849",

+    "GCSE_AustralianNationalSpheroid",

+    "GCSE_Bessel1841",

+    "GCSE_BesselModified",

+    "GCSE_BesselNamibia",

+    "GCSE_Clarke1858",

+    "GCSE_Clarke1866",

+    "GCSE_Clarke1866Michigan",

+    "GCSE_Clarke1880_Benoit",

+    "GCSE_Clarke1880_IGN",

+    "GCSE_Clarke1880_RGS",

+    "GCSE_Clarke1880_Arc",

+    "GCSE_Clarke1880_SGA1922",

+    "GCSE_Everest1830_1937Adjustment",

+    "GCSE_Everest1830_1967Definition",

+    "GCSE_Everest1830_1975Definition",

+    "GCSE_Everest1830Modified",

+    "GCSE_GRS1980",

+    "GCSE_Helmert1906",

+    "GCSE_IndonesianNationalSpheroid",

+    "GCSE_International1924",

+    "GCSE_International1967",

+    "GCSE_Krassowsky1940",

+    "GCSE_NWL9D",

+    "GCSE_NWL10D",

+    "GCSE_Plessis1817",

+    "GCSE_Struve1860",

+    "GCSE_WarOffice",

+    "GCSE_WGS84",

+    "GCSE_GEM10C",

+    "GCSE_OSU86F",

+    "GCSE_OSU91A",

+    "GCSE_Clarke1880",

+    "GCSE_Sphere"

+};

+

+const char *const ff_tiff_geodetic_datum_codes[] = {

+    "Datum_Adindan",

+    "Datum_Australian_Geodetic_Datum_1966",

+    "Datum_Australian_Geodetic_Datum_1984",

+    "Datum_Ain_el_Abd_1970",

+    "Datum_Afgooye",

+    "Datum_Agadez",

+    "Datum_Lisbon",

+    "Datum_Aratu",

+    "Datum_Arc_1950",

+    "Datum_Arc_1960",

+    "Datum_Batavia",

+    "Datum_Barbados",

+    "Datum_Beduaram",

+    "Datum_Beijing_1954",

+    "Datum_Reseau_National_Belge_1950",

+    "Datum_Bermuda_1957",

+    "Datum_Bern_1898",

+    "Datum_Bogota",

+    "Datum_Bukit_Rimpah",

+    "Datum_Camacupa",

+    "Datum_Campo_Inchauspe",

+    "Datum_Cape",

+    "Datum_Carthage",

+    "Datum_Chua",

+    "Datum_Corrego_Alegre",

+    "Datum_Cote_d_Ivoire",

+    "Datum_Deir_ez_Zor",

+    "Datum_Douala",

+    "Datum_Egypt_1907",

+    "Datum_European_Datum_1950",

+    "Datum_European_Datum_1987",

+    "Datum_Fahud",

+    "Datum_Gandajika_1970",

+    "Datum_Garoua",

+    "Datum_Guyane_Francaise",

+    "Datum_Hu_Tzu_Shan",

+    "Datum_Hungarian_Datum_1972",

+    "Datum_Indonesian_Datum_1974",

+    "Datum_Indian_1954",

+    "Datum_Indian_1975",

+    "Datum_Jamaica_1875",

+    "Datum_Jamaica_1969",

+    "Datum_Kalianpur",

+    "Datum_Kandawala",

+    "Datum_Kertau",

+    "Datum_Kuwait_Oil_Company",

+    "Datum_La_Canoa",

+    "Datum_Provisional_S_American_Datum_1956",

+    "Datum_Lake",

+    "Datum_Leigon",

+    "Datum_Liberia_1964",

+    "Datum_Lome",

+    "Datum_Luzon_1911",

+    "Datum_Hito_XVIII_1963",

+    "Datum_Herat_North",

+    "Datum_Mahe_1971",

+    "Datum_Makassar",

+    "Datum_European_Reference_System_1989",

+    "Datum_Malongo_1987",

+    "Datum_Manoca",

+    "Datum_Merchich",

+    "Datum_Massawa",

+    "Datum_Minna",

+    "Datum_Mhast",

+    "Datum_Monte_Mario",

+    "Datum_M_poraloko",

+    "Datum_North_American_Datum_1927",

+    "Datum_NAD_Michigan",

+    "Datum_North_American_Datum_1983",

+    "Datum_Nahrwan_1967",