/* -*- Mode: C++ -*- */

/*

 * libopenraw - rawfile.h

 *

 * Copyright (C) 2005-2016 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/>.

 */

#ifndef LIBOPENRAWPP_RAWFILE_H_

#define LIBOPENRAWPP_RAWFILE_H_

#include <string>

#include <vector>

#include <libopenraw/rawfile.h>

namespace OpenRaw {

namespace IO {

class Stream;

}

class Thumbnail;

class RawData;

class BitmapData;

class MetaValue;

namespace Internals {

class RawContainer;

class ThumbDesc;

struct BuiltinColourMatrix;

}

void init();

class RawFile

{

public:

    typedef ::or_rawfile_type Type;

    typedef ::or_rawfile_typeid TypeId;

    RawFile(const RawFile&) = delete;

    RawFile & operator=(const RawFile &) = delete;

    /** return a NULL terminated list of file extensions 

     * that the library handle. This is purely informational.

     * @return a pointer the list, NULL terminated. The pointer is

     * owned by the library.

     */

    static const char **fileExtensions();

    /** factory method to create the proper RawFile instance.

     * @param _filename the name of the file to load

     * @param _typeHint a hint on the type. Use UNKNOWN_TYPE

     * if you want to let the library detect it for you.

     */

    static RawFile *newRawFile(const char*_filename, 

                               Type _typeHint = OR_RAWFILE_TYPE_UNKNOWN);

    /** factory method to create the proper RawFile instance 

     *  from content 

     * @param buffer the buffer to examine.

     * @param len the number of bytes in the length.

     * @param _typeHint a hint on the type. Use UNKNOWN_TYPE

     * if you want to let the library detect it for you.

     */

    static RawFile *newRawFileFromMemory(const uint8_t *buffer, uint32_t len, 

                                         Type _typeHint = OR_RAWFILE_TYPE_UNKNOWN);

    /** Destructor */

    virtual ~RawFile();

    /** Accessor for the type */

    Type type() const;

    /** The RAW file type ID. Identify it if needed. 

     *  @todo figure how to make this const.

     */

    TypeId typeId();

    // standard api, like get thumbnail

    // and get exif.

    /** list the available thumbnail sizes

     */

    const std::vector<uint32_t> & listThumbnailSizes(void);

    /** Get the thumbnail from the raw file 

     * @param size the square size in px

     * @param thumbnail the thumbnail to extract into

     * @return the error code

     */

    ::or_error getThumbnail(uint32_t size, Thumbnail & thumbnail);

    /** Get the RAW data 

     * @param rawdata the RawData to put the data into

     * @param options the option bits defined by %or_options

     * @return the error code

     */

    ::or_error getRawData(RawData & rawdata, uint32_t options);

    /** Get the rendered image

     * @param bitmapdata the BitmapData to put the image into

     * @param options the option bits. Pass 0 for now.

     * @return the error code

     */

    ::or_error getRenderedImage(BitmapData & bitmapdata, uint32_t options);    

    /** Get the orientation of the image, using Exif enums.

     */

    int32_t getOrientation();

    /**

     * @return the number of items in the colour matrix.

     */

    uint32_t colourMatrixSize();

    /** Get colour matrix

     * @param index The matrix index.

     * @param [out] matrix an array of %size double.

     * @param size the size of the buffer. On out the actual size. If it is too 

     * small the size is adjusted and an error %OR_ERROR_BUF_TOO_SMALL returned.

     * @return an error code.

     */

    ::or_error getColourMatrix1(double* matrix, uint32_t & size);

    ::or_error getColourMatrix2(double* matrix, uint32_t & size);

    /** Get calibration illuminant that match the colour matrix.

     * @return the Exif value. 0 = unknown. Likely not found.

     */

    ExifLightsourceValue getCalibrationIlluminant1();

    ExifLightsourceValue getCalibrationIlluminant2();

    const MetaValue *getMetaValue(int32_t meta_index);

protected:

    struct camera_ids_t {

        const char * model;

        const uint32_t type_id;

    };

    /**

     * Construct a raw file

     * @param _type the type

     */

    RawFile(Type _type);

    /** Set the file type id */

    void _setTypeId(TypeId _type_id);

    /** Just get the type id value. No identification.

     *  You might want to use %typeId() in the general case.

     */

    TypeId _typeId() const;

    /** Get the container. */

    virtual Internals::RawContainer* getContainer() const = 0;

    /** enumerate the thumbnail sizes. 

     * @param list the list to enumerate into

     * @return OR_ERROR_NONE if success

     */

    virtual ::or_error _enumThumbnailSizes(std::vector<uint32_t> &list) = 0;

    /** get the thumbnail of exact size. 

     * @param size the size in pixel of the square

     * @retval thumbnail the thumbnail to load

     * @return OR_ERROR_NONE if success

     * @seealso listThumbnailSizes() to understand how to fetch the sizes

     * available

     */

    virtual ::or_error _getThumbnail(uint32_t size, Thumbnail & thumbnail);

    void _addThumbnail(uint32_t size, const Internals::ThumbDesc& desc);

    /** get the RAW data 

     * @param data the RAW data

     * @param option the option bits

     * @return OR_ERROR_NONE if success

     * Return the data compressed or uncompressed.

     */

    virtual ::or_error _getRawData(RawData & data, uint32_t options) = 0;

    /** get the colour matrix.

     * @param index 1 or 2

     */

    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);

    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 const camera_ids_t s_make[];

    static const camera_ids_t* _lookupCameraId(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))

  indent-tabs-mode:nil

  fill-column:80

  End:

*/

#endif