git.sesse.net Git - ffmpeg/blob - libavcodec/tiff_common.c

   1 /*
   2  * TIFF Common Routines
   3  * Copyright (c) 2013 Thilo Borgmann <thilo.borgmann _at_ mail.de>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * TIFF Common Routines
  25  * @author Thilo Borgmann <thilo.borgmann _at_ mail.de>
  26  */
  27
  28 #include "tiff_common.h"
  29
  30
  31 int ff_tis_ifd(unsigned tag)
  32 {
  33     int i;
  34     for (i = 0; i < FF_ARRAY_ELEMS(ifd_tags); i++) {
  35         if (ifd_tags[i] == tag) {
  36             return i + 1;
  37         }
  38     }
  39     return 0;
  40 }
  41
  42
  43 unsigned ff_tget_short(GetByteContext *gb, int le)
  44 {
  45     return le ? bytestream2_get_le16(gb) : bytestream2_get_be16(gb);
  46 }
  47
  48
  49 unsigned ff_tget_long(GetByteContext *gb, int le)
  50 {
  51     return le ? bytestream2_get_le32(gb) : bytestream2_get_be32(gb);
  52 }
  53
  54
  55 double ff_tget_double(GetByteContext *gb, int le)
  56 {
  57     av_alias64 i = { .u64 = le ? bytestream2_get_le64(gb) : bytestream2_get_be64(gb)};
  58     return i.f64;
  59 }
  60
  61
  62 unsigned ff_tget(GetByteContext *gb, int type, int le)
  63 {
  64     switch (type) {
  65     case TIFF_BYTE:  return bytestream2_get_byte(gb);
  66     case TIFF_SHORT: return ff_tget_short(gb, le);
  67     case TIFF_LONG:  return ff_tget_long(gb, le);
  68     default:         return UINT_MAX;
  69     }
  70 }
  71
  72 static const char *auto_sep(int count, const char *sep, int i, int columns)
  73 {
  74     if (sep)
  75         return i ? sep : "";
  76     if (i && i%columns) {
  77         return ", ";
  78     } else
  79         return columns < count ? "\n" : "";
  80 }
  81
  82 int ff_tadd_rational_metadata(int count, const char *name, const char *sep,
  83                               GetByteContext *gb, int le, AVDictionary **metadata)
  84 {
  85     AVBPrint bp;
  86     char *ap;
  87     int32_t nom, denom;
  88     int i;
  89
  90     if (count >= INT_MAX / sizeof(int64_t) || count <= 0)
  91         return AVERROR_INVALIDDATA;
  92     if (bytestream2_get_bytes_left(gb) < count * sizeof(int64_t))
  93         return AVERROR_INVALIDDATA;
  94
  95     av_bprint_init(&bp, 10 * count, AV_BPRINT_SIZE_UNLIMITED);
  96
  97     for (i = 0; i < count; i++) {
  98         nom   = ff_tget_long(gb, le);
  99         denom = ff_tget_long(gb, le);
 100         av_bprintf(&bp, "%s%7i:%-7i", auto_sep(count, sep, i, 4), nom, denom);
 101     }
 102
 103     if ((i = av_bprint_finalize(&bp, &ap))) {
 104         return i;
 105     }
 106     if (!ap) {
 107         return AVERROR(ENOMEM);
 108     }
 109
 110     av_dict_set(metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);
 111
 112     return 0;
 113 }
 114
 115
 116 int ff_tadd_long_metadata(int count, const char *name, const char *sep,
 117                           GetByteContext *gb, int le, AVDictionary **metadata)
 118 {
 119     AVBPrint bp;
 120     char *ap;
 121     int i;
 122
 123     if (count >= INT_MAX / sizeof(int32_t) || count <= 0)
 124         return AVERROR_INVALIDDATA;
 125     if (bytestream2_get_bytes_left(gb) < count * sizeof(int32_t))
 126         return AVERROR_INVALIDDATA;
 127
 128     av_bprint_init(&bp, 10 * count, AV_BPRINT_SIZE_UNLIMITED);
 129
 130     for (i = 0; i < count; i++) {
 131         av_bprintf(&bp, "%s%7i", auto_sep(count, sep, i, 8), ff_tget_long(gb, le));
 132     }
 133
 134     if ((i = av_bprint_finalize(&bp, &ap))) {
 135         return i;
 136     }
 137     if (!ap) {
 138         return AVERROR(ENOMEM);
 139     }
 140
 141     av_dict_set(metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);
 142
 143     return 0;
 144 }
 145
 146
 147 int ff_tadd_doubles_metadata(int count, const char *name, const char *sep,
 148                              GetByteContext *gb, int le, AVDictionary **metadata)
 149 {
 150     AVBPrint bp;
 151     char *ap;
 152     int i;
 153
 154     if (count >= INT_MAX / sizeof(int64_t) || count <= 0)
 155         return AVERROR_INVALIDDATA;
 156     if (bytestream2_get_bytes_left(gb) < count * sizeof(int64_t))
 157         return AVERROR_INVALIDDATA;
 158
 159     av_bprint_init(&bp, 10 * count, 100 * count);
 160
 161     for (i = 0; i < count; i++) {
 162         av_bprintf(&bp, "%s%.15g", auto_sep(count, sep, i, 4), ff_tget_double(gb, le));
 163     }
 164
 165     if ((i = av_bprint_finalize(&bp, &ap))) {
 166         return i;
 167     }
 168     if (!ap) {
 169         return AVERROR(ENOMEM);
 170     }
 171
 172     av_dict_set(metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);
 173
 174     return 0;
 175 }
 176
 177
 178 int ff_tadd_shorts_metadata(int count, const char *name, const char *sep,
 179                             GetByteContext *gb, int le, AVDictionary **metadata)
 180 {
 181     AVBPrint bp;
 182     char *ap;
 183     int i;
 184
 185     if (count >= INT_MAX / sizeof(int16_t) || count <= 0)
 186         return AVERROR_INVALIDDATA;
 187     if (bytestream2_get_bytes_left(gb) < count * sizeof(int16_t))
 188         return AVERROR_INVALIDDATA;
 189
 190     av_bprint_init(&bp, 10 * count, AV_BPRINT_SIZE_UNLIMITED);
 191
 192     for (i = 0; i < count; i++) {
 193         av_bprintf(&bp, "%s%5i", auto_sep(count, sep, i, 8), ff_tget_short(gb, le));
 194     }
 195
 196     if ((i = av_bprint_finalize(&bp, &ap))) {
 197         return i;
 198     }
 199     if (!ap) {
 200         return AVERROR(ENOMEM);
 201     }
 202
 203     av_dict_set(metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);
 204
 205     return 0;
 206 }
 207
 208
 209 int ff_tadd_bytes_metadata(int count, const char *name, const char *sep,
 210                            GetByteContext *gb, int le, AVDictionary **metadata)
 211 {
 212     AVBPrint bp;
 213     char *ap;
 214     int i;
 215
 216     if (count >= INT_MAX / sizeof(int8_t) || count < 0)
 217         return AVERROR_INVALIDDATA;
 218     if (bytestream2_get_bytes_left(gb) < count * sizeof(int8_t))
 219         return AVERROR_INVALIDDATA;
 220
 221     av_bprint_init(&bp, 10 * count, AV_BPRINT_SIZE_UNLIMITED);
 222
 223     for (i = 0; i < count; i++) {
 224         av_bprintf(&bp, "%s%3i", auto_sep(count, sep, i, 16), bytestream2_get_byte(gb));
 225     }
 226
 227     if ((i = av_bprint_finalize(&bp, &ap))) {
 228         return i;
 229     }
 230     if (!ap) {
 231         return AVERROR(ENOMEM);
 232     }
 233
 234     av_dict_set(metadata, name, ap, AV_DICT_DONT_STRDUP_VAL);
 235
 236     return 0;
 237 }
 238
 239 int ff_tadd_string_metadata(int count, const char *name,
 240                             GetByteContext *gb, int le, AVDictionary **metadata)
 241 {
 242     char *value;
 243
 244     if (bytestream2_get_bytes_left(gb) < count || count < 0)
 245         return AVERROR_INVALIDDATA;
 246
 247     value = av_malloc(count + 1);
 248     if (!value)
 249         return AVERROR(ENOMEM);
 250
 251     bytestream2_get_bufferu(gb, value, count);
 252     value[count] = 0;
 253
 254     av_dict_set(metadata, name, value, AV_DICT_DONT_STRDUP_VAL);
 255     return 0;
 256 }
 257
 258
 259 int ff_tdecode_header(GetByteContext *gb, int *le, int *ifd_offset)
 260 {
 261     if (bytestream2_get_bytes_left(gb) < 8) {
 262         return AVERROR_INVALIDDATA;
 263     }
 264
 265     *le = bytestream2_get_le16u(gb);
 266     if (*le == AV_RB16("II")) {
 267         *le = 1;
 268     } else if (*le == AV_RB16("MM")) {
 269         *le = 0;
 270     } else {
 271         return AVERROR_INVALIDDATA;
 272     }
 273
 274     if (ff_tget_short(gb, *le) != 42) {
 275         return AVERROR_INVALIDDATA;
 276     }
 277
 278     *ifd_offset = ff_tget_long(gb, *le);
 279
 280     return 0;
 281 }
 282
 283
 284 int ff_tread_tag(GetByteContext *gb, int le, unsigned *tag, unsigned *type,
 285                  unsigned *count, int *next)
 286 {
 287     int ifd_tag;
 288     int valid_type;
 289
 290     *tag    = ff_tget_short(gb, le);
 291     *type   = ff_tget_short(gb, le);
 292     *count  = ff_tget_long (gb, le);
 293
 294     ifd_tag    = ff_tis_ifd(*tag);
 295     valid_type = *type != 0 && *type < FF_ARRAY_ELEMS(type_sizes);
 296
 297     *next = bytestream2_tell(gb) + 4;
 298
 299     // check for valid type
 300     if (!valid_type) {
 301         return AVERROR_INVALIDDATA;
 302     }
 303
 304     // seek to offset if this is an IFD-tag or
 305     // if count values do not fit into the offset value
 306     if (ifd_tag || (*count > 4 || !(type_sizes[*type] * (*count) <= 4 || *type == TIFF_STRING))) {
 307         bytestream2_seek(gb, ff_tget_long (gb, le), SEEK_SET);
 308     }
 309
 310     return 0;
 311 }