/*
 * Copyright 2007-2008, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef RAW_H
#define RAW_H


#include "ReadHelper.h"


struct jhead;
struct tiff_tag;


struct image_meta_info {
	char	manufacturer[64];
	char	model[128];
	char	software[64];
	float	flash_used;
	float	iso_speed;
	float	shutter;
	float	aperture;
	float	focal_length;
	double	pixel_aspect;
	uint32	raw_width;
	uint32	raw_height;
	int		flip;
	uint32	dng_version;
	uint32	shot_order;
	int32	black;
	int32	maximum;
	float	camera_multipliers[4];
	float	pre_multipliers[4];
	float	rgb_camera[3][4];	/* RGB from camera color */
	time_t	timestamp;
};

struct image_data_info {
	uint32	width;
	uint32	height;
	uint32	output_width;
	uint32	output_height;
	uint32	bits_per_sample;
	uint32	compression;
	uint32	photometric_interpretation;
	uint32	flip;
	uint32	samples;
	uint32	bytes;
	off_t	data_offset;
	bool	is_raw;
};

#define COMPRESSION_NONE		1
#define COMPRESSION_OLD_JPEG	6		// Old JPEG (before 6.0)
#define COMPRESSION_PACKBITS	32773	// Macintosh RLE


typedef void (*monitor_hook)(const char* message, float percentage, void* data);

class DCRaw {
	public:
		DCRaw(BPositionIO& stream);
		~DCRaw();

		status_t Identify();
		status_t ReadImageAt(uint32 index, uint8*& outputBuffer,
			size_t& bufferSize);

		void GetMetaInfo(image_meta_info& metaInfo) const;
		uint32 CountImages() const;
		status_t ImageAt(uint32 index, image_data_info& info) const;

		status_t GetEXIFTag(off_t& offset, size_t& length,
			bool& bigEndian) const;
		void SetProgressMonitor(monitor_hook hook, void* data);

		void SetHalfSize(bool half);

	private:
		int32 _AllocateImage();
		image_data_info& _Raw();
		image_data_info& _Thumb();
		void _CorrectIndex(uint32& index) const;
		uint16& _Bayer(int32 column, int32 row);
		int32 _FilterCoefficient(int32 column, int32 row);
		int32 _FlipIndex(uint32 row, uint32 col, uint32 flip);
		bool _SupportsCompression(image_data_info& info) const;
		bool _IsCanon() const;
		bool _IsKodak() const;
		bool _IsNikon() const;
		bool _IsOlympus() const;
		bool _IsPentax() const;
		bool _IsSamsung() const;

		// image manipulation and conversion
		void _ScaleColors();
		void _WaveletDenoise();
		void _PreInterpolate();
		void _CameraToCIELab(ushort cam[4], float lab[3]);
		void _CameraXYZCoefficients(double cam_xyz[4][3]);
		void _AdobeCoefficients(const char *manufacturer, const char *model);
		void _BorderInterpolate(uint32 border);
		void _AHDInterpolate();
		void _PseudoInverse(double (*in)[3], double (*out)[3], uint32 size);
		void _ConvertToRGB();
		void _GammaLookUpTable(uchar* lut);

		void _ParseThumbTag(off_t baseOffset, uint32 offsetTag, uint32 lengthTag);
		void _ParseManufacturerTag(off_t baseOffset);
		void _ParseEXIF(off_t baseOffset);
		void _ParseLinearTable(uint32 length);
		void _FixupValues();

		// Lossless JPEG
		void _InitDecoder();
		uchar *_MakeDecoder(const uchar* source, int level);
		void _InitDecodeBits();
		uint32 _GetDecodeBits(uint32 numBits);
		status_t _LosslessJPEGInit(struct jhead* jh, bool infoOnly);
		int _LosslessJPEGDiff(struct decode *dindex);
		void _LosslessJPEGRow(struct jhead *jh, int jrow);

		// RAW Loader
		void _LoadRAWUnpacked(const image_data_info& image);
		void _LoadRAWPacked12(const image_data_info& info);
		void _MakeCanonDecoder(uint32 table);
		bool _CanonHasLowBits();
		void _LoadRAWCanonCompressed(const image_data_info& info);
		void _LoadRAWLosslessJPEG(const image_data_info& image);
		void _LoadRAW(const image_data_info& info);

		// Image writers
		void _WriteJPEG(image_data_info& image, uint8* outputBuffer);
		void _WriteRGB32(image_data_info& image, uint8* outputBuffer);

		// TIFF
		time_t _ParseTIFFTimestamp(bool reversed);
		void _ParseTIFFTag(off_t baseOffset, tiff_tag& tag, off_t& offset);
		status_t _ParseTIFFImageFileDirectory(off_t baseOffset, uint32 offset);
		status_t _ParseTIFFImageFileDirectory(off_t baseOffset);
		status_t _ParseTIFF(off_t baseOffset);

		TReadHelper	fRead;
		image_meta_info fMeta;
		image_data_info* fImages;
		uint32		fNumImages;

		int32		fRawIndex;
		int32		fThumbIndex;
		uint32		fDNGVersion;
		bool		fIsTIFF;

		uint16		(*fImageData)[4];
			// output image data
		float		fThreshold;
		int32		fShrink;
		bool		fHalfSize;
		bool		fUseCameraWhiteBalance;
		bool		fUseAutoWhiteBalance;
		bool		fRawColor;
		bool		fUseGamma;
		float		fBrightness;
		int32		fOutputColor;
		int32		fHighlight;
		int32		fDocumentMode;
		uint32		fOutputWidth;
		uint32		fOutputHeight;
		uint32		fInputWidth;
		uint32		fInputHeight;
		int32		fTopMargin;
		int32		fLeftMargin;
		uint32		fUniqueID;
		uint32		fColors;
		uint16		fWhite[8][8];
		float		fUserMultipliers[4];
		uint16*		fCurve;
		uint16		fCR2Slice[3];
		uint32*		fOutputProfile;
		uint32		fOutputBitsPerSample;
		int32		(*fHistogram)[4];
		float*		cbrt;
		float		xyz_cam[3][4];
			// TODO: find better names for these...

		// Lossless JPEG
		decode*		fDecodeBuffer;
		decode*		fSecondDecode;
		decode*		fFreeDecode;
		int			fDecodeLeaf;
		uint32		fDecodeBits;
		uint32		fDecodeBitsRead;
		bool		fDecodeBitsReset;
		bool		fDecodeBitsZeroAfterMax;

		uint32		fFilters;
		uint32		fEXIFFilters;
		off_t		fEXIFOffset;
		uint32		fEXIFLength;

		off_t		fCurveOffset;

		monitor_hook fProgressMonitor;
		void*		fProgressData;
};

#endif	// RAW_H