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