OLD | NEW |
(Empty) | |
| 1 /* exif-content.c |
| 2 * |
| 3 * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net> |
| 4 * |
| 5 * This library is free software; you can redistribute it and/or |
| 6 * modify it under the terms of the GNU Lesser General Public |
| 7 * License as published by the Free Software Foundation; either |
| 8 * version 2 of the License, or (at your option) any later version. |
| 9 * |
| 10 * This library is distributed in the hope that it will be useful, |
| 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 13 * Lesser General Public License for more details. |
| 14 * |
| 15 * You should have received a copy of the GNU Lesser General Public |
| 16 * License along with this library; if not, write to the |
| 17 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| 18 * Boston, MA 02110-1301 USA. |
| 19 */ |
| 20 |
| 21 #include <config.h> |
| 22 |
| 23 #include <libexif/exif-content.h> |
| 24 #include <libexif/exif-system.h> |
| 25 |
| 26 #include <stdlib.h> |
| 27 #include <stdio.h> |
| 28 #include <string.h> |
| 29 |
| 30 /* unused constant |
| 31 * static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00
}; |
| 32 */ |
| 33 |
| 34 struct _ExifContentPrivate |
| 35 { |
| 36 unsigned int ref_count; |
| 37 |
| 38 ExifMem *mem; |
| 39 ExifLog *log; |
| 40 }; |
| 41 |
| 42 ExifContent * |
| 43 exif_content_new (void) |
| 44 { |
| 45 ExifMem *mem = exif_mem_new_default (); |
| 46 ExifContent *content = exif_content_new_mem (mem); |
| 47 |
| 48 exif_mem_unref (mem); |
| 49 |
| 50 return content; |
| 51 } |
| 52 |
| 53 ExifContent * |
| 54 exif_content_new_mem (ExifMem *mem) |
| 55 { |
| 56 ExifContent *content; |
| 57 |
| 58 if (!mem) return NULL; |
| 59 |
| 60 content = exif_mem_alloc (mem, (ExifLong) sizeof (ExifContent)); |
| 61 if (!content) |
| 62 return NULL; |
| 63 content->priv = exif_mem_alloc (mem, |
| 64 (ExifLong) sizeof (ExifContentPrivate)); |
| 65 if (!content->priv) { |
| 66 exif_mem_free (mem, content); |
| 67 return NULL; |
| 68 } |
| 69 |
| 70 content->priv->ref_count = 1; |
| 71 |
| 72 content->priv->mem = mem; |
| 73 exif_mem_ref (mem); |
| 74 |
| 75 return content; |
| 76 } |
| 77 |
| 78 void |
| 79 exif_content_ref (ExifContent *content) |
| 80 { |
| 81 content->priv->ref_count++; |
| 82 } |
| 83 |
| 84 void |
| 85 exif_content_unref (ExifContent *content) |
| 86 { |
| 87 content->priv->ref_count--; |
| 88 if (!content->priv->ref_count) |
| 89 exif_content_free (content); |
| 90 } |
| 91 |
| 92 void |
| 93 exif_content_free (ExifContent *content) |
| 94 { |
| 95 ExifMem *mem = (content && content->priv) ? content->priv->mem : NULL; |
| 96 unsigned int i; |
| 97 |
| 98 if (!content) return; |
| 99 |
| 100 for (i = 0; i < content->count; i++) |
| 101 exif_entry_unref (content->entries[i]); |
| 102 exif_mem_free (mem, content->entries); |
| 103 |
| 104 if (content->priv) { |
| 105 exif_log_unref (content->priv->log); |
| 106 } |
| 107 |
| 108 exif_mem_free (mem, content->priv); |
| 109 exif_mem_free (mem, content); |
| 110 exif_mem_unref (mem); |
| 111 } |
| 112 |
| 113 void |
| 114 exif_content_dump (ExifContent *content, unsigned int indent) |
| 115 { |
| 116 char buf[1024]; |
| 117 unsigned int i; |
| 118 |
| 119 for (i = 0; i < 2 * indent; i++) |
| 120 buf[i] = ' '; |
| 121 buf[i] = '\0'; |
| 122 |
| 123 if (!content) |
| 124 return; |
| 125 |
| 126 printf ("%sDumping exif content (%u entries)...\n", buf, |
| 127 content->count); |
| 128 for (i = 0; i < content->count; i++) |
| 129 exif_entry_dump (content->entries[i], indent + 1); |
| 130 } |
| 131 |
| 132 void |
| 133 exif_content_add_entry (ExifContent *c, ExifEntry *entry) |
| 134 { |
| 135 ExifEntry **entries; |
| 136 if (!c || !c->priv || !entry || entry->parent) return; |
| 137 |
| 138 /* One tag can only be added once to an IFD. */ |
| 139 if (exif_content_get_entry (c, entry->tag)) { |
| 140 exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "ExifContent", |
| 141 "An attempt has been made to add " |
| 142 "the tag '%s' twice to an IFD. This is against " |
| 143 "specification.", exif_tag_get_name (entry->tag)); |
| 144 return; |
| 145 } |
| 146 |
| 147 entries = exif_mem_realloc (c->priv->mem, |
| 148 c->entries, sizeof (ExifEntry*) * (c->count + 1)); |
| 149 if (!entries) return; |
| 150 entry->parent = c; |
| 151 entries[c->count++] = entry; |
| 152 c->entries = entries; |
| 153 exif_entry_ref (entry); |
| 154 } |
| 155 |
| 156 void |
| 157 exif_content_remove_entry (ExifContent *c, ExifEntry *e) |
| 158 { |
| 159 unsigned int i; |
| 160 ExifEntry **t, *temp; |
| 161 |
| 162 if (!c || !c->priv || !e || (e->parent != c)) return; |
| 163 |
| 164 /* Search the entry */ |
| 165 for (i = 0; i < c->count; i++) |
| 166 if (c->entries[i] == e) |
| 167 break; |
| 168 |
| 169 if (i == c->count) |
| 170 return; |
| 171 |
| 172 /* Remove the entry */ |
| 173 temp = c->entries[c->count-1]; |
| 174 if (c->count > 1) { |
| 175 t = exif_mem_realloc (c->priv->mem, c->entries, |
| 176 sizeof(ExifEntry*) * (c->count - 1)); |
| 177 if (!t) { |
| 178 return; |
| 179 } |
| 180 c->entries = t; |
| 181 c->count--; |
| 182 if (i != c->count) { /* we deallocated the last slot already */ |
| 183 memmove (&t[i], &t[i + 1], sizeof (ExifEntry*) * (c->cou
nt - i - 1)); |
| 184 t[c->count-1] = temp; |
| 185 } |
| 186 } else { |
| 187 exif_mem_free (c->priv->mem, c->entries); |
| 188 c->entries = NULL; |
| 189 c->count = 0; |
| 190 } |
| 191 e->parent = NULL; |
| 192 exif_entry_unref (e); |
| 193 } |
| 194 |
| 195 ExifEntry * |
| 196 exif_content_get_entry (ExifContent *content, ExifTag tag) |
| 197 { |
| 198 unsigned int i; |
| 199 |
| 200 if (!content) |
| 201 return (NULL); |
| 202 |
| 203 for (i = 0; i < content->count; i++) |
| 204 if (content->entries[i]->tag == tag) |
| 205 return (content->entries[i]); |
| 206 return (NULL); |
| 207 } |
| 208 |
| 209 void |
| 210 exif_content_foreach_entry (ExifContent *content, |
| 211 ExifContentForeachEntryFunc func, void *data) |
| 212 { |
| 213 unsigned int i; |
| 214 |
| 215 if (!content || !func) |
| 216 return; |
| 217 |
| 218 for (i = 0; i < content->count; i++) |
| 219 func (content->entries[i], data); |
| 220 } |
| 221 |
| 222 void |
| 223 exif_content_log (ExifContent *content, ExifLog *log) |
| 224 { |
| 225 if (!content || !content->priv || !log || content->priv->log == log) |
| 226 return; |
| 227 |
| 228 if (content->priv->log) exif_log_unref (content->priv->log); |
| 229 content->priv->log = log; |
| 230 exif_log_ref (log); |
| 231 } |
| 232 |
| 233 ExifIfd |
| 234 exif_content_get_ifd (ExifContent *c) |
| 235 { |
| 236 if (!c || !c->parent) return EXIF_IFD_COUNT; |
| 237 |
| 238 return |
| 239 ((c)->parent->ifd[EXIF_IFD_EXIF] == (c)) ? EXIF_IFD_EXIF : |
| 240 ((c)->parent->ifd[EXIF_IFD_0] == (c)) ? EXIF_IFD_0 : |
| 241 ((c)->parent->ifd[EXIF_IFD_1] == (c)) ? EXIF_IFD_1 : |
| 242 ((c)->parent->ifd[EXIF_IFD_GPS] == (c)) ? EXIF_IFD_GPS : |
| 243 ((c)->parent->ifd[EXIF_IFD_INTEROPERABILITY] == (c)) ? EXIF_IFD_
INTEROPERABILITY : |
| 244 EXIF_IFD_COUNT; |
| 245 } |
| 246 |
| 247 static void |
| 248 fix_func (ExifEntry *e, void *UNUSED(data)) |
| 249 { |
| 250 exif_entry_fix (e); |
| 251 } |
| 252 |
| 253 /*! |
| 254 * Check if this entry is unknown and if so, delete it. |
| 255 * \note Be careful calling this function in a loop. Deleting an entry from |
| 256 * an ExifContent changes the index of subsequent entries, as well as the |
| 257 * total size of the entries array. |
| 258 */ |
| 259 static void |
| 260 remove_not_recorded (ExifEntry *e, void *UNUSED(data)) |
| 261 { |
| 262 ExifIfd ifd = exif_entry_get_ifd(e) ; |
| 263 ExifContent *c = e->parent; |
| 264 ExifDataType dt = exif_data_get_data_type (c->parent); |
| 265 ExifTag t = e->tag; |
| 266 |
| 267 if (exif_tag_get_support_level_in_ifd (t, ifd, dt) == |
| 268 EXIF_SUPPORT_LEVEL_NOT_RECORDED) { |
| 269 exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "exif-content", |
| 270 "Tag 0x%04x is not recorded in IFD '%s' and has
therefore been " |
| 271 "removed.", t, exif_ifd_get_name (ifd)); |
| 272 exif_content_remove_entry (c, e); |
| 273 } |
| 274 |
| 275 } |
| 276 |
| 277 void |
| 278 exif_content_fix (ExifContent *c) |
| 279 { |
| 280 ExifIfd ifd = exif_content_get_ifd (c); |
| 281 ExifDataType dt; |
| 282 ExifEntry *e; |
| 283 unsigned int i, num; |
| 284 |
| 285 if (!c) |
| 286 return; |
| 287 |
| 288 dt = exif_data_get_data_type (c->parent); |
| 289 |
| 290 /* |
| 291 * First of all, fix all existing entries. |
| 292 */ |
| 293 exif_content_foreach_entry (c, fix_func, NULL); |
| 294 |
| 295 /* |
| 296 * Go through each tag and if it's not recorded, remove it. If one |
| 297 * is removed, exif_content_foreach_entry() will skip the next entry, |
| 298 * so if this happens do the loop again from the beginning to ensure |
| 299 * they're all checked. This could be avoided if we stop relying on |
| 300 * exif_content_foreach_entry but loop intelligently here. |
| 301 */ |
| 302 do { |
| 303 num = c->count; |
| 304 exif_content_foreach_entry (c, remove_not_recorded, NULL); |
| 305 } while (num != c->count); |
| 306 |
| 307 /* |
| 308 * Then check for non-existing mandatory tags and create them if needed |
| 309 */ |
| 310 num = exif_tag_table_count(); |
| 311 for (i = 0; i < num; ++i) { |
| 312 const ExifTag t = exif_tag_table_get_tag (i); |
| 313 if (exif_tag_get_support_level_in_ifd (t, ifd, dt) == |
| 314 EXIF_SUPPORT_LEVEL_MANDATORY) { |
| 315 if (exif_content_get_entry (c, t)) |
| 316 /* This tag already exists */ |
| 317 continue; |
| 318 exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "exif-conte
nt", |
| 319 "Tag '%s' is mandatory in IFD '%s' and h
as therefore been added.", |
| 320 exif_tag_get_name_in_ifd (t, ifd), exif_
ifd_get_name (ifd)); |
| 321 e = exif_entry_new (); |
| 322 exif_content_add_entry (c, e); |
| 323 exif_entry_initialize (e, t); |
| 324 exif_entry_unref (e); |
| 325 } |
| 326 } |
| 327 } |
OLD | NEW |