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 31int 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 43unsigned ff_tget_short(GetByteContext *gb, int le) 44{ 45 return le ? bytestream2_get_le16(gb) : bytestream2_get_be16(gb); 46} 47 48 49unsigned ff_tget_long(GetByteContext *gb, int le) 50{ 51 return le ? bytestream2_get_le32(gb) : bytestream2_get_be32(gb); 52} 53 54 55double 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 62unsigned 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 72static 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 82int 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 116int 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 147int 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 178int ff_tadd_shorts_metadata(int count, const char *name, const char *sep, 179 GetByteContext *gb, int le, int is_signed, 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 int v = is_signed ? (int16_t)ff_tget_short(gb, le) : ff_tget_short(gb, le); 194 av_bprintf(&bp, "%s%5i", auto_sep(count, sep, i, 8), v); 195 } 196 197 if ((i = av_bprint_finalize(&bp, &ap))) { 198 return i; 199 } 200 if (!ap) { 201 return AVERROR(ENOMEM); 202 } 203 204 av_dict_set(metadata, name, ap, AV_DICT_DONT_STRDUP_VAL); 205 206 return 0; 207} 208 209 210int ff_tadd_bytes_metadata(int count, const char *name, const char *sep, 211 GetByteContext *gb, int le, int is_signed, AVDictionary **metadata) 212{ 213 AVBPrint bp; 214 char *ap; 215 int i; 216 217 if (count >= INT_MAX / sizeof(int8_t) || count < 0) 218 return AVERROR_INVALIDDATA; 219 if (bytestream2_get_bytes_left(gb) < count * sizeof(int8_t)) 220 return AVERROR_INVALIDDATA; 221 222 av_bprint_init(&bp, 10 * count, AV_BPRINT_SIZE_UNLIMITED); 223 224 for (i = 0; i < count; i++) { 225 int v = is_signed ? (int8_t)bytestream2_get_byte(gb) : bytestream2_get_byte(gb); 226 av_bprintf(&bp, "%s%3i", auto_sep(count, sep, i, 16), v); 227 } 228 229 if ((i = av_bprint_finalize(&bp, &ap))) { 230 return i; 231 } 232 if (!ap) { 233 return AVERROR(ENOMEM); 234 } 235 236 av_dict_set(metadata, name, ap, AV_DICT_DONT_STRDUP_VAL); 237 238 return 0; 239} 240 241int ff_tadd_string_metadata(int count, const char *name, 242 GetByteContext *gb, int le, AVDictionary **metadata) 243{ 244 char *value; 245 246 if (bytestream2_get_bytes_left(gb) < count || count < 0) 247 return AVERROR_INVALIDDATA; 248 249 value = av_malloc(count + 1); 250 if (!value) 251 return AVERROR(ENOMEM); 252 253 bytestream2_get_bufferu(gb, value, count); 254 value[count] = 0; 255 256 av_dict_set(metadata, name, value, AV_DICT_DONT_STRDUP_VAL); 257 return 0; 258} 259 260 261int ff_tdecode_header(GetByteContext *gb, int *le, int *ifd_offset) 262{ 263 if (bytestream2_get_bytes_left(gb) < 8) { 264 return AVERROR_INVALIDDATA; 265 } 266 267 *le = bytestream2_get_le16u(gb); 268 if (*le == AV_RB16("II")) { 269 *le = 1; 270 } else if (*le == AV_RB16("MM")) { 271 *le = 0; 272 } else { 273 return AVERROR_INVALIDDATA; 274 } 275 276 if (ff_tget_short(gb, *le) != 42) { 277 return AVERROR_INVALIDDATA; 278 } 279 280 *ifd_offset = ff_tget_long(gb, *le); 281 282 return 0; 283} 284 285 286int ff_tread_tag(GetByteContext *gb, int le, unsigned *tag, unsigned *type, 287 unsigned *count, int *next) 288{ 289 int ifd_tag; 290 int valid_type; 291 292 *tag = ff_tget_short(gb, le); 293 *type = ff_tget_short(gb, le); 294 *count = ff_tget_long (gb, le); 295 296 ifd_tag = ff_tis_ifd(*tag); 297 valid_type = *type != 0 && *type < FF_ARRAY_ELEMS(type_sizes); 298 299 *next = bytestream2_tell(gb) + 4; 300 301 // check for valid type 302 if (!valid_type) { 303 return AVERROR_INVALIDDATA; 304 } 305 306 // seek to offset if this is an IFD-tag or 307 // if count values do not fit into the offset value 308 if (ifd_tag || (*count > 4 || !(type_sizes[*type] * (*count) <= 4 || *type == TIFF_STRING))) { 309 bytestream2_seek(gb, ff_tget_long (gb, le), SEEK_SET); 310 } 311 312 return 0; 313} 314