rawfile.hpp

/* -*- Mode: C++ -*- */
/*
 * libopenraw - rawfile.hpp
 *
 * Copyright (C) 2005-2020 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 <string>
#include <vector>
 
#include <libopenraw/rawfile.h>
 
#include "ifddir.hpp"
#include "makernotedir.hpp"
 
namespace OpenRaw {
 
class Thumbnail;
class RawData;
class BitmapData;
class MetaValue;
class MetadataIterator;
 
namespace Internals {
class RawContainer;
class ThumbDesc;
typedef std::map<uint32_t, ::or_rawfile_typeid> ModelIdMap;
struct BuiltinColourMatrix;
template<typename T>
void audit_coefficients();
}
 
void init();
 
class RawFile
{
    template<typename T>
    friend void Internals::audit_coefficients();
 
public:
    typedef ::or_rawfile_type Type;
    typedef ::or_rawfile_typeid TypeId;
 
    RawFile(const RawFile&) = delete;
    RawFile & operator=(const RawFile &) = delete;
 
    static const char **fileExtensions();
 
    static RawFile *newRawFile(const char*_filename,
                               Type typeHint = OR_RAWFILE_TYPE_UNKNOWN);
    static RawFile *newRawFileFromMemory(const uint8_t *buffer, uint32_t len,
                                         Type typeHint = OR_RAWFILE_TYPE_UNKNOWN);
 
    virtual ~RawFile();
    Type type() const;
 
    TypeId typeId();
    TypeId vendorId();
 
    // standard api, like get thumbnail
    // and get exif.
 
    const std::vector<uint32_t> & listThumbnailSizes(void);
    ::or_error getThumbnail(uint32_t size, Thumbnail & thumbnail);
 
    ::or_error getRawData(RawData & rawdata, uint32_t options);
 
    ::or_error getRenderedImage(BitmapData & bitmapdata, uint32_t options);
 
    uint32_t getOrientation();
 
    uint32_t colourMatrixSize();
 
    ::or_error getColourMatrix1(double* matrix, uint32_t& size);
    ::or_error getColourMatrix2(double* matrix, uint32_t& size);
 
    ExifLightsourceValue getCalibrationIlluminant1();
    ExifLightsourceValue getCalibrationIlluminant2();
 
    virtual or_colour_matrix_origin getColourMatrixOrigin() const;
 
    Internals::IfdDir::Ref cfaIfd();
    Internals::IfdDir::Ref mainIfd();
    Internals::IfdDir::Ref exifIfd();
    Internals::MakerNoteDir::Ref makerNoteIfd();
 
    const MetaValue *getMetaValue(int32_t meta_index);
 
    MetadataIterator* getMetadataIterator();
protected:
    virtual Internals::IfdDir::Ref _locateCfaIfd() = 0;
    virtual Internals::IfdDir::Ref _locateMainIfd() = 0;
    virtual Internals::IfdDir::Ref _locateExifIfd();
    virtual Internals::MakerNoteDir::Ref _locateMakerNoteIfd();
 
    struct camera_ids_t {
        const char * model;
        const uint32_t type_id;
    };
    RawFile(Type _type);
 
    static RawFile::TypeId modelid_to_typeid(const std::map<uint32_t, RawFile::TypeId>& model_map,
                                             uint32_t model_id);
    virtual bool vendorCameraIdLocation(Internals::IfdDir::Ref& ifd, uint16_t& index,
                                        const Internals::ModelIdMap*& model_map);
    void _setTypeId(TypeId _type_id);
    TypeId _typeId() const;
 
    virtual Internals::RawContainer* getContainer() const = 0;
 
    virtual ::or_error _enumThumbnailSizes(std::vector<uint32_t> &list) = 0;
 
    virtual ::or_error _getThumbnail(uint32_t size, Thumbnail & thumbnail);
    void _addThumbnail(uint32_t size, Internals::ThumbDesc&& desc);
 
    virtual ::or_error _getRawData(RawData & data, uint32_t options) = 0;
 
    virtual ::or_error _getColourMatrix(uint32_t index, double* matrix, uint32_t & size);
    virtual ExifLightsourceValue _getCalibrationIlluminant(uint16_t index);
    virtual MetaValue *_getMetaValue(int32_t /*meta_index*/) = 0;
 
    TypeId _typeIdFromModel(const std::string& make, const std::string & model);
    TypeId _typeIdFromMake(const std::string& make, const std::string& model);
    void _setIdMap(const camera_ids_t *map);
    void _setMatrices(const Internals::BuiltinColourMatrix* matrices);
    const Internals::BuiltinColourMatrix* _getMatrices() const;
 
    virtual void _identifyId() = 0;
 
    static ::or_error _getBuiltinLevels(const Internals::BuiltinColourMatrix* m,
                                        TypeId type_id,
                                        uint16_t & black,
                                        uint16_t & white);
    static ::or_error _getBuiltinColourMatrix(const Internals::BuiltinColourMatrix* m,
                                              TypeId type_id,
                                              double* matrix,
                                              uint32_t & size);
 
private:
    static Type identify(const char*_filename);
    static ::or_error identifyBuffer(const uint8_t* buff, size_t len,
                                     Type &_type);
    static ::or_error identifyIOBuffer(IO::Stream::Ptr& stream,
                                       RawFile::Type& _type);
    static const camera_ids_t s_make[];
    static const camera_ids_t* _lookupCameraId(const camera_ids_t * map,
                                               const std::string& value);
    static const camera_ids_t* lookupVendorId(const camera_ids_t * map,
                                              const std::string& value);
 
    class Private;
 
    Private *d;
};
 
}
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0))
  c-basic-offset: 4
  tab-width: 4
  indent-tabs-mode:nil
  fill-column:80
  End:
*/