ifddir.hpp

/* -*- mode:c++; tab-width:4; c-basic-offset:4; indent-tabs-mode:nil; -*- */
/*
 * libopenraw - ifddir.hpp
 *
 * Copyright (C) 2006-2022 Hubert Figuière
 *
 * 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 3 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, see
 * <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
#include <sys/types.h>
#include <exception>
#include <map>
#include <memory>
#include <vector>
 
#include <libopenraw/debug.h>
 
#include "ifdentry.hpp"
#include "trace.hpp"
#include "option.hpp"
#include "exif/exif_tags.hpp"
 
namespace OpenRaw {
namespace Internals {
 
typedef or_ifd_dir_type IfdDirType;
 
class IfdFileContainer;
 
class IfdDir {
public:
    typedef std::weak_ptr<IfdDir> WeakRef;
    typedef std::shared_ptr<IfdDir> Ref;
    typedef std::vector<Ref> RefVec;
    typedef std::map<uint16_t, IfdEntry::Ref> Entries;
 
    IfdDir(off_t _offset, RawContainer& _container, IfdDirType _type /*= OR_IFDDIR_OTHER */, const TagTable& tag_table = exif_tag_names);
    virtual ~IfdDir();
 
    IfdDirType type() const
        { return m_type; }
    void setType(IfdDirType type_)
        { m_type = type_; }
 
    off_t baseOffset() const
        { return m_base_offset; }
    void setBaseOffset(off_t base)
        { m_base_offset = base; }
 
    bool isPrimary() const;
    bool isThumbnail() const;
 
    off_t offset() const { return m_offset; }
    const RawContainer& container() const { return m_container; }
    RawContainer& container() { return m_container; }
 
    virtual bool load();
    int numTags() { return m_entries.size(); }
    IfdEntry::Ref getEntry(uint16_t id) const;
    const Entries& entries() const
        {
            return m_entries;
        }
    RawContainer::EndianType endian() const
        {
            return m_endian;
        }
    void setEndian(RawContainer::EndianType _endian)
        {
            m_endian = _endian;
        }
 
    template <typename T>
    Option<T> getValue(uint16_t id) const
    {
        IfdEntry::Ref e = getEntry(id);
        if (e != NULL) {
            try {
                return Option<T>(getEntryValue<T>(*e));
            }
            catch (const std::exception &ex) {
                LOGERR("Exception raised %s fetch value for %u\n", ex.what(), id);
            }
        }
        return Option<T>();
    }
 
    Option<uint32_t> getIntegerValue(uint16_t id);
 
    off_t nextIFD();
 
    Ref getSubIFD(uint32_t idx = 0) const;
 
    Option<std::vector<IfdDir::Ref>> getSubIFDs();
 
    Ref getExifIFD();
 
    Ref getMakerNoteIfd(or_rawfile_type file_type);
 
    void setTagTable(const TagTable& tag_table)
        {
            m_tag_table = &tag_table;
        }
    const char* getTagName(uint32_t tag) const;
 
    template <typename T>
    Option<std::vector<T>> getEntryArrayValue(IfdEntry& e) const;
    template<typename T>
    T getEntryValue(IfdEntry& e, uint32_t idx = 0, bool ignore_type = false) const;
 
    uint32_t getEntryIntegerArrayItemValue(IfdEntry& e, int idx) const;
 
    MetaValue* makeMetaValue(IfdEntry& e) const;
protected:
    Entries m_entries;
private:
    IfdDirType m_type;
    off_t m_offset;
    RawContainer& m_container;
    const TagTable* m_tag_table;
    off_t m_base_offset;
    RawContainer::EndianType m_endian;
};
 
 
template <typename T>
Option<std::vector<T>> IfdDir::getEntryArrayValue(IfdEntry& entry) const
{
    try {
        std::vector<T> array;
        array.reserve(entry.count());
        for (uint32_t i = 0; i < entry.count(); i++) {
            array.push_back(getEntryValue<T>(entry, i));
        }
        return Option<decltype(array)>(array);
    }
    catch(const std::exception& e)
    {
        LOGERR("Exception: %s\n", e.what());
    }
    return OptionNone();
}
 
template <typename T>
T IfdDir::getEntryValue(IfdEntry& e, uint32_t idx, bool ignore_type) const
    noexcept(false)
{
    /* format undefined means that we don't check the type */
    if(!ignore_type && (e.type() != IFD::EXIF_FORMAT_UNDEFINED)) {
        if (e.type() != IfdTypeTrait<T>::type) {
            throw BadTypeException();
        }
    }
    if (idx + 1 > e.count()) {
        throw OutOfRangeException();
    }
 
    if (!e.loadData(IfdTypeTrait<T>::size, m_base_offset)) {
        throw TooBigException();
    }
 
    const uint8_t *data = e.dataptr();
    data += (IfdTypeTrait<T>::size * idx);
    T val;
    if (e.endian() == RawContainer::ENDIAN_LITTLE) {
        val = IfdTypeTrait<T>::EL(data, e.count() - idx);
    } else {
        val = IfdTypeTrait<T>::BE(data, e.count() - idx);
    }
    return val;
}
 
}
}