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


#include "RAWTranslator.h"
#include "ConfigView.h"
#ifdef USES_LIBRAW
#include "LibRAW.h"
#else
#include "RAW.h"
#endif

#include <Catalog.h>
#include <BufferIO.h>
#include <Messenger.h>
#include <TranslatorRoster.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "RAWTranslator"


class FreeAllocation {
	public:
		FreeAllocation(void* buffer)
			:
			fBuffer(buffer)
		{
		}

		~FreeAllocation()
		{
			free(fBuffer);
		}

	private:
		void*	fBuffer;
};

struct progress_data {
	BMessenger	monitor;
	BMessage	message;
};

// Extensions that ShowImage supports
const char* kDocumentCount = "/documentCount";
const char* kDocumentIndex = "/documentIndex";
const char* kProgressMonitor = "/progressMonitor";
const char* kProgressMessage = "/progressMessage";


// The input formats that this translator supports.
static const translation_format sInputFormats[] = {
	{
		RAW_IMAGE_FORMAT,
		B_TRANSLATOR_BITMAP,
		RAW_IN_QUALITY,
		RAW_IN_CAPABILITY,
		"image/x-vnd.adobe-dng",
		"Adobe Digital Negative"
	},
	{
		RAW_IMAGE_FORMAT,
		B_TRANSLATOR_BITMAP,
		RAW_IN_QUALITY,
		RAW_IN_CAPABILITY,
		"image/x-vnd.photo-raw",
		"Digital Photo RAW image"
	}
};

// The output formats that this translator supports.
static const translation_format sOutputFormats[] = {
	{
		B_TRANSLATOR_BITMAP,
		B_TRANSLATOR_BITMAP,
		BITS_OUT_QUALITY,
		BITS_OUT_CAPABILITY,
		"image/x-be-bitmap",
		"Be Bitmap Format (RAWTranslator)"
	}
};

// Default settings for the Translator
static const TranSetting sDefaultSettings[] = {
	{B_TRANSLATOR_EXT_HEADER_ONLY, TRAN_SETTING_BOOL, false},
	{B_TRANSLATOR_EXT_DATA_ONLY, TRAN_SETTING_BOOL, false}
};

const uint32 kNumInputFormats = sizeof(sInputFormats) / sizeof(translation_format);
const uint32 kNumOutputFormats = sizeof(sOutputFormats) / sizeof(translation_format);
const uint32 kNumDefaultSettings = sizeof(sDefaultSettings) / sizeof(TranSetting);

const char* kShortName1 = B_TRANSLATE("RAW images");
const char* kShortInfo1 = B_TRANSLATE("RAW image translator");


//	#pragma mark -


RAWTranslator::RAWTranslator()
	: BaseTranslator(kShortName1, kShortInfo1,
		RAW_TRANSLATOR_VERSION,
		sInputFormats, kNumInputFormats,
		sOutputFormats, kNumOutputFormats,
		"RAWTranslator_Settings",
		sDefaultSettings, kNumDefaultSettings,
		B_TRANSLATOR_BITMAP, RAW_IMAGE_FORMAT)
{
}


RAWTranslator::~RAWTranslator()
{
}


status_t
RAWTranslator::DerivedIdentify(BPositionIO *stream,
	const translation_format *format, BMessage *settings,
	translator_info *info, uint32 outType)
{
	if (!outType)
		outType = B_TRANSLATOR_BITMAP;
	if (outType != B_TRANSLATOR_BITMAP)
		return B_NO_TRANSLATOR;

	BBufferIO io(stream, 128 * 1024, false);
#ifdef USES_LIBRAW
	LibRAW raw(io);
#else
	DCRaw raw(io);
#endif
	status_t status;

	try {
		status = raw.Identify();
	} catch (status_t error) {
		status = error;
	}

	if (status < B_OK)
		return B_NO_TRANSLATOR;

	image_meta_info meta;
	raw.GetMetaInfo(meta);

	if (settings) {
		int32 count = raw.CountImages();

		// Add page count to ioExtension
		settings->RemoveName(kDocumentCount);
		settings->AddInt32(kDocumentCount, count);

		// Check if a document index has been specified
		int32 index;
		if (settings->FindInt32(kDocumentIndex, &index) == B_OK)
			index--;
		else
			index = 0;

		if (index < 0 || index >= count)
			return B_NO_TRANSLATOR;
	}

	info->type = RAW_IMAGE_FORMAT;
	info->group = B_TRANSLATOR_BITMAP;
	info->quality = RAW_IN_QUALITY;
	info->capability = RAW_IN_CAPABILITY;
	snprintf(info->name, sizeof(info->name), 
		B_TRANSLATE_COMMENT("%s RAW image", "Parameter (%s) is the name of "
		"the manufacturer (like 'Canon')"), meta.manufacturer);
	strcpy(info->MIME, "image/x-vnd.photo-raw");

	return B_OK;
}


/*static*/ void
RAWTranslator::_ProgressMonitor(const char* message, float percentage,
	void* _data)
{
	progress_data& data = *(progress_data*)_data;

	BMessage update(data.message);
	update.AddString("message", message);
	update.AddFloat("percent", percentage);
	update.AddInt64("time", system_time());

	data.monitor.SendMessage(&update);
}


status_t
RAWTranslator::DerivedTranslate(BPositionIO* stream,
	const translator_info* info, BMessage* settings,
	uint32 outType, BPositionIO* target, int32 baseType)
{
	if (!outType)
		outType = B_TRANSLATOR_BITMAP;
	if (outType != B_TRANSLATOR_BITMAP || baseType != 0)
		return B_NO_TRANSLATOR;

	BBufferIO io(stream, 1024 * 1024, false);
#ifdef USES_LIBRAW
	LibRAW raw(io);
#else
	DCRaw raw(io);
#endif

	bool headerOnly = false;

	progress_data progressData;
	BMessenger monitor;

	if (settings != NULL) {
		settings->FindBool(B_TRANSLATOR_EXT_HEADER_ONLY, &headerOnly);

		bool half;
		if (settings->FindBool("raw:half_size", &half) == B_OK && half)
			raw.SetHalfSize(true);

		if (settings->FindMessenger(kProgressMonitor,
				&progressData.monitor) == B_OK
			&& settings->FindMessage(kProgressMessage,
				&progressData.message) == B_OK) {
			raw.SetProgressMonitor(&_ProgressMonitor, &progressData);
			_ProgressMonitor("Reading Image Data", 0, &progressData);
		}
	}

	int32 imageIndex = 0;
	uint8* buffer = NULL;
	size_t bufferSize;
	status_t status;

	try {
		status = raw.Identify();

		if (status == B_OK && settings) {
			// Check if a document index has been specified
			if (settings->FindInt32(kDocumentIndex, &imageIndex) == B_OK)
				imageIndex--;
			else
				imageIndex = 0;

			if (imageIndex < 0 || imageIndex >= (int32)raw.CountImages())
				status = B_BAD_VALUE;
		}
		if (status == B_OK && !headerOnly)
			status = raw.ReadImageAt(imageIndex, buffer, bufferSize);
	} catch (status_t error) {
		status = error;
	}

	if (status < B_OK)
		return B_NO_TRANSLATOR;

	FreeAllocation _(buffer);
		// frees the buffer on destruction

	image_meta_info meta;
	raw.GetMetaInfo(meta);

	image_data_info data;
	raw.ImageAt(imageIndex, data);

	if (!data.is_raw) {
		// let others handle embedded JPEG data
		BMemoryIO io(buffer, bufferSize);
		BMessage buffer;
		if (meta.flip != 1) {
			// preserve orientation
			if (settings == NULL)
				settings = &buffer;
			settings->AddInt32("exif:orientation", meta.flip);
		}

		BTranslatorRoster* roster = BTranslatorRoster::Default();
		return roster->Translate(&io, NULL, settings, target, outType);
	}

	// retrieve EXIF data
	off_t exifOffset;
	size_t exifLength;
	bool bigEndian;
	if (settings != NULL && raw.GetEXIFTag(exifOffset, exifLength, bigEndian) == B_OK) {
		uint8* exifBuffer = (uint8*)malloc(exifLength + 16);
		if (exifBuffer != NULL) {
			// add fake TIFF header to EXIF data
			struct {
				uint16	endian;
				uint16	tiff_marker;
				uint32	offset;
				uint16	null;
			} _PACKED header;
			header.endian = bigEndian ? 'MM' : 'II';
			header.tiff_marker = 42;
			header.offset = 16;
			header.null = 0;
			memcpy(exifBuffer, &header, sizeof(header));

			if (io.ReadAt(exifOffset, exifBuffer + 16, exifLength)
					== (ssize_t)exifLength)
				settings->AddData("exif", B_RAW_TYPE, exifBuffer, exifLength + 16);

			free(exifBuffer);
		}
	}

#ifdef USES_LIBRAW
	uint32 dataSize = data.output_width * 3 * data.output_height;
#else
	uint32 dataSize = data.output_width * 4 * data.output_height;
#endif

	TranslatorBitmap header;
	header.magic = B_TRANSLATOR_BITMAP;
	header.bounds.Set(0, 0, data.output_width - 1, data.output_height - 1);
#ifdef USES_LIBRAW
	header.rowBytes = data.output_width * 3;
	header.colors = B_RGB24_BIG;
#else
	header.rowBytes = data.output_width * 4;
	header.colors = B_RGB32;
#endif
	header.dataSize = dataSize;

	// write out Be's Bitmap header
	swap_data(B_UINT32_TYPE, &header, sizeof(TranslatorBitmap),
		B_SWAP_HOST_TO_BENDIAN);
	ssize_t bytesWritten = target->Write(&header, sizeof(TranslatorBitmap));
	if (bytesWritten < B_OK)
		return bytesWritten;

	if ((size_t)bytesWritten != sizeof(TranslatorBitmap))
		return B_IO_ERROR;

	if (headerOnly)
		return B_OK;

	bytesWritten = target->Write(buffer, dataSize);
	if (bytesWritten < B_OK)
		return bytesWritten;

	if ((size_t)bytesWritten != dataSize)
		return B_IO_ERROR;

	return B_OK;
}


BView *
RAWTranslator::NewConfigView(TranslatorSettings *settings)
{
	return new ConfigView();
}


//	#pragma mark -


BTranslator *
make_nth_translator(int32 n, image_id you, uint32 flags, ...)
{
	if (n != 0)
		return NULL;

	return new RAWTranslator();
}