328 lines
7.7 KiB
C
Executable File
328 lines
7.7 KiB
C
Executable File
/* exif-content.c
|
|
*
|
|
* Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
|
|
*
|
|
* This library 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 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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 this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <libexif/exif-content.h>
|
|
#include <libexif/exif-system.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
/* unused constant
|
|
* static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
|
|
*/
|
|
|
|
struct _ExifContentPrivate
|
|
{
|
|
unsigned int ref_count;
|
|
|
|
ExifMem *mem;
|
|
ExifLog *log;
|
|
};
|
|
|
|
ExifContent *
|
|
exif_content_new (void)
|
|
{
|
|
ExifMem *mem = exif_mem_new_default ();
|
|
ExifContent *content = exif_content_new_mem (mem);
|
|
|
|
exif_mem_unref (mem);
|
|
|
|
return content;
|
|
}
|
|
|
|
ExifContent *
|
|
exif_content_new_mem (ExifMem *mem)
|
|
{
|
|
ExifContent *content;
|
|
|
|
if (!mem) return NULL;
|
|
|
|
content = exif_mem_alloc (mem, (ExifLong) sizeof (ExifContent));
|
|
if (!content)
|
|
return NULL;
|
|
content->priv = exif_mem_alloc (mem,
|
|
(ExifLong) sizeof (ExifContentPrivate));
|
|
if (!content->priv) {
|
|
exif_mem_free (mem, content);
|
|
return NULL;
|
|
}
|
|
|
|
content->priv->ref_count = 1;
|
|
|
|
content->priv->mem = mem;
|
|
exif_mem_ref (mem);
|
|
|
|
return content;
|
|
}
|
|
|
|
void
|
|
exif_content_ref (ExifContent *content)
|
|
{
|
|
content->priv->ref_count++;
|
|
}
|
|
|
|
void
|
|
exif_content_unref (ExifContent *content)
|
|
{
|
|
content->priv->ref_count--;
|
|
if (!content->priv->ref_count)
|
|
exif_content_free (content);
|
|
}
|
|
|
|
void
|
|
exif_content_free (ExifContent *content)
|
|
{
|
|
ExifMem *mem = (content && content->priv) ? content->priv->mem : NULL;
|
|
unsigned int i;
|
|
|
|
if (!content) return;
|
|
|
|
for (i = 0; i < content->count; i++)
|
|
exif_entry_unref (content->entries[i]);
|
|
exif_mem_free (mem, content->entries);
|
|
|
|
if (content->priv) {
|
|
exif_log_unref (content->priv->log);
|
|
}
|
|
|
|
exif_mem_free (mem, content->priv);
|
|
exif_mem_free (mem, content);
|
|
exif_mem_unref (mem);
|
|
}
|
|
|
|
void
|
|
exif_content_dump (ExifContent *content, unsigned int indent)
|
|
{
|
|
char buf[1024];
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < 2 * indent; i++)
|
|
buf[i] = ' ';
|
|
buf[i] = '\0';
|
|
|
|
if (!content)
|
|
return;
|
|
|
|
printf ("%sDumping exif content (%u entries)...\n", buf,
|
|
content->count);
|
|
for (i = 0; i < content->count; i++)
|
|
exif_entry_dump (content->entries[i], indent + 1);
|
|
}
|
|
|
|
void
|
|
exif_content_add_entry (ExifContent *c, ExifEntry *entry)
|
|
{
|
|
ExifEntry **entries;
|
|
if (!c || !c->priv || !entry || entry->parent) return;
|
|
|
|
/* One tag can only be added once to an IFD. */
|
|
if (exif_content_get_entry (c, entry->tag)) {
|
|
exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "ExifContent",
|
|
"An attempt has been made to add "
|
|
"the tag '%s' twice to an IFD. This is against "
|
|
"specification.", exif_tag_get_name (entry->tag));
|
|
return;
|
|
}
|
|
|
|
entries = exif_mem_realloc (c->priv->mem,
|
|
c->entries, sizeof (ExifEntry*) * (c->count + 1));
|
|
if (!entries) return;
|
|
entry->parent = c;
|
|
entries[c->count++] = entry;
|
|
c->entries = entries;
|
|
exif_entry_ref (entry);
|
|
}
|
|
|
|
void
|
|
exif_content_remove_entry (ExifContent *c, ExifEntry *e)
|
|
{
|
|
unsigned int i;
|
|
ExifEntry **t, *temp;
|
|
|
|
if (!c || !c->priv || !e || (e->parent != c)) return;
|
|
|
|
/* Search the entry */
|
|
for (i = 0; i < c->count; i++)
|
|
if (c->entries[i] == e)
|
|
break;
|
|
|
|
if (i == c->count)
|
|
return;
|
|
|
|
/* Remove the entry */
|
|
temp = c->entries[c->count-1];
|
|
if (c->count > 1) {
|
|
t = exif_mem_realloc (c->priv->mem, c->entries,
|
|
sizeof(ExifEntry*) * (c->count - 1));
|
|
if (!t) {
|
|
return;
|
|
}
|
|
c->entries = t;
|
|
c->count--;
|
|
if (i != c->count) { /* we deallocated the last slot already */
|
|
memmove (&t[i], &t[i + 1], sizeof (ExifEntry*) * (c->count - i - 1));
|
|
t[c->count-1] = temp;
|
|
}
|
|
} else {
|
|
exif_mem_free (c->priv->mem, c->entries);
|
|
c->entries = NULL;
|
|
c->count = 0;
|
|
}
|
|
e->parent = NULL;
|
|
exif_entry_unref (e);
|
|
}
|
|
|
|
ExifEntry *
|
|
exif_content_get_entry (ExifContent *content, ExifTag tag)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (!content)
|
|
return (NULL);
|
|
|
|
for (i = 0; i < content->count; i++)
|
|
if (content->entries[i]->tag == tag)
|
|
return (content->entries[i]);
|
|
return (NULL);
|
|
}
|
|
|
|
void
|
|
exif_content_foreach_entry (ExifContent *content,
|
|
ExifContentForeachEntryFunc func, void *data)
|
|
{
|
|
unsigned int i;
|
|
|
|
if (!content || !func)
|
|
return;
|
|
|
|
for (i = 0; i < content->count; i++)
|
|
func (content->entries[i], data);
|
|
}
|
|
|
|
void
|
|
exif_content_log (ExifContent *content, ExifLog *log)
|
|
{
|
|
if (!content || !content->priv || !log || content->priv->log == log)
|
|
return;
|
|
|
|
if (content->priv->log) exif_log_unref (content->priv->log);
|
|
content->priv->log = log;
|
|
exif_log_ref (log);
|
|
}
|
|
|
|
ExifIfd
|
|
exif_content_get_ifd (ExifContent *c)
|
|
{
|
|
if (!c || !c->parent) return EXIF_IFD_COUNT;
|
|
|
|
return
|
|
((c)->parent->ifd[EXIF_IFD_EXIF] == (c)) ? EXIF_IFD_EXIF :
|
|
((c)->parent->ifd[EXIF_IFD_0] == (c)) ? EXIF_IFD_0 :
|
|
((c)->parent->ifd[EXIF_IFD_1] == (c)) ? EXIF_IFD_1 :
|
|
((c)->parent->ifd[EXIF_IFD_GPS] == (c)) ? EXIF_IFD_GPS :
|
|
((c)->parent->ifd[EXIF_IFD_INTEROPERABILITY] == (c)) ? EXIF_IFD_INTEROPERABILITY :
|
|
EXIF_IFD_COUNT;
|
|
}
|
|
|
|
static void
|
|
fix_func (ExifEntry *e, void *UNUSED(data))
|
|
{
|
|
exif_entry_fix (e);
|
|
}
|
|
|
|
/*!
|
|
* Check if this entry is unknown and if so, delete it.
|
|
* \note Be careful calling this function in a loop. Deleting an entry from
|
|
* an ExifContent changes the index of subsequent entries, as well as the
|
|
* total size of the entries array.
|
|
*/
|
|
static void
|
|
remove_not_recorded (ExifEntry *e, void *UNUSED(data))
|
|
{
|
|
ExifIfd ifd = exif_entry_get_ifd(e) ;
|
|
ExifContent *c = e->parent;
|
|
ExifDataType dt = exif_data_get_data_type (c->parent);
|
|
ExifTag t = e->tag;
|
|
|
|
if (exif_tag_get_support_level_in_ifd (t, ifd, dt) ==
|
|
EXIF_SUPPORT_LEVEL_NOT_RECORDED) {
|
|
exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "exif-content",
|
|
"Tag 0x%04x is not recorded in IFD '%s' and has therefore been "
|
|
"removed.", t, exif_ifd_get_name (ifd));
|
|
exif_content_remove_entry (c, e);
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
exif_content_fix (ExifContent *c)
|
|
{
|
|
ExifIfd ifd = exif_content_get_ifd (c);
|
|
ExifDataType dt;
|
|
ExifEntry *e;
|
|
unsigned int i, num;
|
|
|
|
if (!c)
|
|
return;
|
|
|
|
dt = exif_data_get_data_type (c->parent);
|
|
|
|
/*
|
|
* First of all, fix all existing entries.
|
|
*/
|
|
exif_content_foreach_entry (c, fix_func, NULL);
|
|
|
|
/*
|
|
* Go through each tag and if it's not recorded, remove it. If one
|
|
* is removed, exif_content_foreach_entry() will skip the next entry,
|
|
* so if this happens do the loop again from the beginning to ensure
|
|
* they're all checked. This could be avoided if we stop relying on
|
|
* exif_content_foreach_entry but loop intelligently here.
|
|
*/
|
|
do {
|
|
num = c->count;
|
|
exif_content_foreach_entry (c, remove_not_recorded, NULL);
|
|
} while (num != c->count);
|
|
|
|
/*
|
|
* Then check for non-existing mandatory tags and create them if needed
|
|
*/
|
|
num = exif_tag_table_count();
|
|
for (i = 0; i < num; ++i) {
|
|
const ExifTag t = exif_tag_table_get_tag (i);
|
|
if (exif_tag_get_support_level_in_ifd (t, ifd, dt) ==
|
|
EXIF_SUPPORT_LEVEL_MANDATORY) {
|
|
if (exif_content_get_entry (c, t))
|
|
/* This tag already exists */
|
|
continue;
|
|
exif_log (c->priv->log, EXIF_LOG_CODE_DEBUG, "exif-content",
|
|
"Tag '%s' is mandatory in IFD '%s' and has therefore been added.",
|
|
exif_tag_get_name_in_ifd (t, ifd), exif_ifd_get_name (ifd));
|
|
e = exif_entry_new ();
|
|
exif_content_add_entry (c, e);
|
|
exif_entry_initialize (e, t);
|
|
exif_entry_unref (e);
|
|
}
|
|
}
|
|
}
|